ArrayList&Linkedlist&泛型的简单使用

toString()函数一般都需要重写




ArrayList list = new ArrayList();        //创建空集合
Iterator it = list.iterator();            //创建指向某集合的迭代器，相当于指针
list.add(Object o);                //添加元素到集合中

list.get(int index);                  //根据索引找到对应元素
System.out.println(newList);            //集合中的元素可以直接输出
while(it.hasNext()){                //遍历集合元素
    Object obj = it.next();    
}    
list.contatin(Object obj);            //判断集合是否含有某元素    





当ArrayList集合中的元素为对象时，如果不重写equals方法，比较对象时比较的是两者地址的值，一定是不相同的
因此一般都会重写equals方法，如：
public boolean equals(Object obj) {
    Person p = (Person)obj;
    return this.name.equals(p.name) && this.age == p.age;
}





LinkedList ll=new LinkedList();            //创建空链表
ll.addFirst(Object obj);            //链表头部插入元素
ll.addLast(Object obj);                //链表尾部插入元素
ll.getFirst()；                    //获取链表头部的第一个元素
ll.getLast();                    //获取链表尾部的第一个元素
ll.removeFirst();                //删除链表头部的第一个元素
ll.removeLast();                //删除链表尾部的第一个元素
ll.get(int index);                //根据索引获取对应的元素
ll.empty();                    //判断链表是否为空
System.out.println(ll);                //可以直接输出链表的所有元素





泛型好处
    提高安全性(将运行期的错误转换到编译期) 
    省去强转的麻烦
泛型基本使用
    <>中放的必须是指定引用数据类型 





ArrayList<Person> list = new ArrayList<Person>();        //特定只能存放Person对象
ArrayList<Person> list = new ArrayList<>();            //另一种写法
ArrayList<Object> list != new ArrayList<Person>();        //集合的泛型要保证前后的数据类型一致
Iterator<Person> it = list.iterator();                //迭代器也要改为泛型





Tool<String> t = new Tool<>();                    //自定义类的泛型
t.show(true);
class Tool<Q> {                            //定义泛型类型
    private Q q;
    public Q getObj() {
        return q;
    }
    public void setObj(Q q) {
        this.q = q;
    }
    public<T> void show(T t) {                //方法泛型最好与类的泛型一致
        System.out.println(t);                //如果不一致,需要在方法上声明该泛型
    }
    public static<W> void print(W w) {            //静态方法必须声明自己的泛型
        System.out.println(w);
    }
}





public interface Inter <T> {                    //接口的泛型
    public void show(T t);
}
class Demo implements Inter<String> {                //推荐用这种
    public void show(String t) {
        System.out.println(t);
    }
}
class Demo<T> implements Inter<T> {}                //没有必要在实现接口的时候给自己类加泛型




ArrayList<Person> list1 = new ArrayList<>();
ArrayList<Student> list2 = new ArrayList<>();
list1.addAll(list2);                        //将集合中的元素全部插入到另一集合后面





int[] arr = {11,22,33,44,55};                    //增强for循环，只能用来遍历，不能修改
for (int i : arr) {
    System.out.println(i);
}




ArrayList<String> list = new ArrayList<>();
for(int i = 0; i < list.size(); i++) {
    if("b".equals(list.get(i))) {                
        list.remove(i--);                //通过索引删除元素
    }
}





import static java.util.Arrays.sort;            //静态导入
int[] arr = {55,22,33,44,11};
sort(arr);





String[] arr = {"a","b","c"};
List<String> list = Arrays.asList(arr);                //将数组转换成集合
//list.add("d");                        //不能添加
System.out.println(list);





int[] arr = {11,22,33,44,55};            
List<int[]> list = Arrays.asList(arr);            //基本数据类型的数组转换成集合,会将整个数组当作一个对象转换
System.out.println(list);                //集合中的元素为每一个数组的地址





ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
        
String[] arr = list.toArray(new String[list.size()]);    //当集合转换数组时,数组长度如果是小于等于集合的size时,转换后的数组长度等于集合的size，如果数组的长度大于了size,分配的数组长度就和你指定的长度一样