list
- 遍历集合
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
for(int i=0 ;i<list.size();i++){
Object o=list.get(i);
System.out.println(o);
}
}
Vector
-
概述：Vector 类可以实现可增长的对象数组 , Vector 是同步的。
-
功能：
void addElement (E obj) //添加指定的组件到这个向量的结束，增加其大小由一个。 E elementAt(int index) //返回指定索引处的组件。 Enumeration<E> elements()// 返回此向量的组件的枚举。 E firstElement() //返回第一个组件（在指数 0项目）这个载体。 E lastElement() //返回向量的最后一个组件。 boolean removeElement(Object obj) //从该向量中移除第一个（最低索引）发生的参数。 void removeElementAt(int index) //在指定的索引中删除组件。 void setElementAt(E obj, int index) //设置组件在指定的 index这个向量是指定的对象。
LinkedList
-
概述：List 接口的链接列表实现 , 此实现不是同步的
-
功能
void addFirst(E e)； //在此列表的开始处插入指定的元素。 void addLast(E e)； //将指定的元素列表的结束。 E getLast()； //返回此列表中的最后一个元素。 E peek()； //检索，但不删除，此列表的头（第一个元素）。 E peekFirst()； //检索，但不删除该列表的第一个元素，或返回 null如果这个列表是空的。 E peekLast() //检索，但不删除该列表的最后一个元素，或返回 null如果这个列表是空的。 E poll() //检索并删除此列表的头（第一个元素）。 E pollFirst() //检索并移除此列表的第一个元素，或返回 null如果这个列表是空的。 E pollLast() //检索并移除此列表的最后一个元素，或返回 null如果这个列表是空的。 E pop() //从这个列表所表示的堆栈中弹出一个元素。 void push(E e) //将一个元素推到由该列表所表示的堆栈上。 E removeLast() //移除并返回此列表中的最后一个元素。 E removeFirst() //移除并返回此列表中的第一个元素。 -
例：
//需求：请用LinkedList模拟栈数据结构的集合，并测试 //栈的特点：先进的后出，后进的先出。 public static void main(String[] args) { LinkedList list = new LinkedList(); list.addFirst(200); list.addFirst(300); list.addFirst(400); Object first = list.pop(); list.addLast(first); Object first1 = list.pop(); System.out.println(first); list.addLast(first1); Object first2 = list.pop(); System.out.println(first1); list.addLast(first2); } -
去掉集合中重复的元素
public static void main(String[] args) { ArrayList list = new ArrayList(); list.add(20); list.add(20); list.add(20); list.add(20); list.add(120); list.add(320); list.add(320); list.add(120); list.add(20); list.add(230); list.add(204); list.add(203); list.add(20); list.add(120); list.add(320); list.add(320); list.add(120); list.add(20); list.add(230); list.add(204); list.add(203); for (int i = 0; i < list.size() - 1; i++) { Object o = list.get(i); if (list.indexOf(o) != list.lastIndexOf(o)) { list.remove(o); i--; } } System.out.println(list); } -
ArrayList去除集合中字符串的重复值(字符串的内容相同)
public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("aaa"); list.add("aaa"); list.add("bbb"); list.add("bbb"); list.add("ccc"); list.add("ccc"); ArrayList newList = new ArrayList(); for(int i=0;i<list.size();i++){ Object o=list.get(i); if(!newList.contains(o)){ newList.add(o); } } System.out.println(newList); }
泛型机制
-
泛型机制：JDK1.5之后引入的一种机制。就是把数据类型明确工作，推迟到创建对象或调用方法时，才去明确的一种机制。
泛型的好处：能够提高代码的扩展性，避免了向下转型，可以将问题提前到编译期。 -
泛型，只在编译期，有效在运行期，就擦除了。
-
如果不规定泛型，在输出时需要进行向下转型，否则会报错。
ArrayList list = new ArrayList(); list.add("abc"); list.add(100); list.add(3.21); Object o = list.get(0); String str= (String) o; System.out.println(str.length()); -
规定泛型后就不需要进行向下转型。
ArrayList<String> list2 = new ArrayList<String>(); list2.add("abc"); String s = list2.get(0); System.out.println(s); -
泛型类
public class MyClass<T> { private T t; private Integer num; public T getT() { return t; } public void setT(T t) { this.t = t; } } //泛型类型必须是引用类型 -
泛型接口
interface Inter<T> { public void show(T t); } class demo implements Inter<String>{ public void show(String str){ System.out.println(str); } } //当实现类确定传入的类型时，可以直接指定类型interface Inter<T> { public void show(T t); } class demo<T> implements Inter<T>{ public void show(T t){ System.out.println(t); } } -
泛型方法
Class Demo{ public <T> void test1(T t){ System.out.println("this is test1" + t); } public <T> void test2(T t){ System.out.println("this is test2" + t); } }/*由于泛型类的所有方法都只能使用同一不确定的类型。 那么当我们需要不同方法操作不同的不确定类型时，就可以将泛型定义在方法上。*/ -
泛型通配符
public class MyTest { public static void main(String[] args) { //? 泛型通配符 ArrayList<?> objects = new ArrayList<Dog>(); ArrayList<?> objects2 = new ArrayList<Cat>(); ArrayList<?> objects3 = new ArrayList<Animal>(); System.out.println("===================================="); //向上限定 ArrayList<? super Cat> list = new ArrayList<Animal>(); ArrayList<? super Animal> list2 = new ArrayList<Animal>(); ArrayList<? super Animal> list3 = new ArrayList<Object>(); //向下限定 ArrayList<? extends Animal> list4 = new ArrayList<Animal>(); ArrayList<? extends Animal> list5 = new ArrayList<Cat>(); ArrayList<? extends Animal> list6 = new ArrayList<Dog>(); System.out.println("============================================"); ArrayList<Integer> a= new ArrayList<>(); a.add(200); ArrayList<Integer> b = new ArrayList<>(); b.add(2000); a.addAll(b); } } class Animal{ } class Dog extends Animal{ } class Cat extends Animal{ }
新式for循环
-
老式
int[] arr={20,30,50}; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } -
新式
//for(容器中的元素的数据类型 变量名:容器名) for(int a:arr){ System.out.println(a); } -
注意：新式for循环在遍历集合时，底层用的还是迭代器，你在遍历途中，如果改变集合的长度，就会报并发修改异常（ConcurrentModificationException）。
可变参数
-
可变参数，本质是一个数组，一次可以接收多个同类型的参数。
-
//如果一个方法的形参有多个参数，那么可变参数，应该是最后一个。 private static int add(int b,int... a) { int sum=b; for (int i : a) { sum += i; } return sum; } -
把一个数组转换集合。 int[] arr={20,30,40}; //传的是一个基本类型的数组，他是把这个数组对象，放到集合中 List<int[]> ints = Arrays.asList(arr); System.out.println(ints); //[[I@1b6d3586] //传入的是一个包装类型的数组，他是吧数组中的元素，取出来放到集合中 System.out.println(ints.get(0)[0]); //20 Integer[] arr2 = {20, 30, 40}; List<Integer> integers = Arrays.asList(arr2); System.out.println(integers);//[20, 30, 40] //传入多个包装类型的数组，那么他是把多个数组对象，放到集合中。 Integer[] arr3 = {20, 30, 40}; Integer[] arr4 = {20, 30, 400}; List<Integer[]> integers1 = Arrays.asList(arr3, arr4); Integer integer = integers1.get(1)[2]; System.out.println(integer);//400
163
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
