集合,泛型，增强for循环

集合

1. String 会重写Equals方法 和tostring方法

2. 放在集合里面的元素要重写equals方法

 public static void main(String[] args) {
        //创建多态
        Collection c = new ArrayList();
        User u1 =new User("美国队长");
        User u2 =new User("雷神");
        c.add(u1);
        c.add(u2);
        User u3 =new User("雷神");
        //User没有重写equals 所以，这里比较的是内存地址
        System.out.println(c.contains(u3));//false
​
​
    }
}
​
class User{
        private String name;
​
    public User() {
    }
​
    public User(String name) {
        this.name = name;
    }

public static void main(String[] args) {
        //创建多态
        Collection c = new ArrayList();
        User u1 =new User("美国队长");
        User u2 =new User("雷神");
        c.add(u1);
        c.add(u2);
        User u3 =new User("雷神");
      // User重写了equals方法，比较的是内存
        System.out.println(c.contains(u3));//true
​
​
    }
}
​
class User{
        private String name;
​
    public User() {
    }
​
    public User(String name) {
        this.name = name;
    }
   //重写equals方法
    public boolean equals(Object o) {
        if (o==null||!(o instanceof User))return false;
        if (this == o) return true;
        User u = (User)o;
        if (this.name.equals(((User) o).name)) {
            return true;
        }
        return false;
    }

Collection 判断会调用equals方法

自己创建的类药重写equals方法和toString方法

1. 每次数据结构发生改变（增加了元素或者删除了元素，迭代器都要重新获取）否则出现异常

2. 在迭代集合元素的过程中，不能调用集合的remove（）方法，要用迭代器的remove方法

    public static void main(String[] args) {
        //创建对象
        List li = new ArrayList();
        li.add(123);
        li.add(234);
        li.add(345);
        li.add(456);
        li.add(567);
        li.add(0, 999);
        //创建迭代器对象
        Iterator it = li.iterator();
        while(it.hasNext()){
            Object next = it.next();
            System.out.println(next);
        }
        System.out.println("-----------------------------------");
        // list特有的便利方法
        for (int i = 0; i < li.size(); i++) {
            Object o = li.get(i); //获取下表为i的值
            System.out.println(o);
        }
        //999最后出现的下表
        System.out.println(li.lastIndexOf(999));
        // 123第一次出现的下表
        System.out.println(li.indexOf(123));
    }
}

ArrayList集合

1. 默认初始化容量为10（地产先创建了一个长度为0的数组，当添加第一个元素的时候，初始化长度为0）；

2. 集合底层是一个object【】数组

3. ArrayList集合的扩容：原容量的1.5倍

单链表

1. 任何一个节点都有两个属性

   • 第一个：存储的数据

   • 第二个下一节点的内存地址

2. 链表优点：随机增删元素效率较高

3. 链表缺点：查询效率较低，每一次查找每个元素的时候都要从头节点开始

泛型

 public static void main(String[] args) {
        //创建泛型
        List<Animal> a = new ArrayList<Animal>();
        //创建CAt Dog对象
        Cat cat = new Cat();
        Dog dog = new Dog();
        //增加元素
        a.add(cat);
        a.add(dog);
        //创建迭代器对象
        Iterator<Animal> it = a.iterator();
        //遍历
        while(it.hasNext()){
            Animal next = it.next();
            next.move();
        }
    }
}
class Animal{
    public void move(){
        System.out.println("动物们开始跑步");
    }
​
}
class Cat extends Animal{
    public void CatchMouse(){
        System.out.println("杰瑞抓老鼠");
    }
​
}
class Dog extends Animal{
    public void KanJia(){
        System.out.println("雪橇三傻啦雪橇");
    }

1. 泛型的优点

   • 集合中存储的元素类型统一（制定了Animal，就只能村Animal）

   • 从集合中取出的元素类型是泛型指定的类型，不需要进行强制转换

   1. 泛型的缺点

      • 导致集合存储的元素缺乏多样性

增强for循环

语法结构：

for（原属类型 变量名：数组或集合）{

System.out.println（变量名）

}

int[] arr ={1,2,3,4,5,6};
fo(int data : arr){
    System.out.println(data)
}
//data 是指数组中的每一个元素

缺点：没有下标