Collection中(List集合)

0. UML
统一建模语言

1. Collection接口
1.1 集合框架的顶级接口
1.2 是Set和List的父接口
1.3 但不是Map的父接口

集合中只能添加引用类型数据

2. List接口
2.1 特点：有序、对象可以重复
2.2 遍历方式
2.2.1 下标
2.2.2 foreach(>=jdk1.5)
2.2.3 迭代器Iterator（原理）
2.3 List优化
初始容量10,负载因子0.5

指定初始容量
2.4 List元素删除

3. 泛型
JDK1.5之后
以类型作为参数的类就叫泛型
作用：提高程序健壮性，简化代码
泛型的默认值是Object

4. 装箱、拆箱
值类型->引用类型 装箱
引用类型->值类型 拆箱
jdk1.5之后引入了自动装箱及自动拆箱功能

5. ArrayList、LinkedList、Vector区别
ArrayList：以连续的数组结构存储数据，查询块（下标）、增删改慢
LinkedList：以链表的结构存储数据，查询慢、增删改快
Vector：增删改查都慢，已过时

 代码展示:

package com.zking.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        //List接口
        //1.特点:有序,对象可以重复
        List lst=new ArrayList<>();
        lst.add("小猪");
        lst.add("小马");
        lst.add("小鸡");
        //有序:数据存入顺序和输出顺序一致
        for (Object st : lst) {
            System.out.println(st);
        }
        System.out.println("===========================");
        //不唯一  可以出现重复数据
        lst.add("小猪");
        for (Object st : lst) {
            System.out.println(st);
        }
        
        
        //2.遍历方式
        System.out.println("===========下标遍历============");
        //1)下标遍历for(下标)
        for (int i = 0; i < lst.size(); i++) {
            System.out.println(lst.get(i));
        }
        
        System.out.println("===========foreach遍历============");
        //2)foreach(>=jdk1.5)
        for (Object st : lst) {
            System.out.println(st);
        }
        
        //3)迭代器Iterator
        System.out.println("================迭代器Iterator遍历===============");
        Iterator s=lst.iterator();
        while(s.hasNext()) {
            System.out.println(s.next());
        }
        //3.删除
        //1)for下标删除
    /*    System.out.println("=======for下标删除========");
        System.out.println("删除前:"+lst.size());
        for (int i = 0; i < lst.size(); i++) {
            lst.remove(i);
        }
        System.out.println("删除后:"+lst.size());*/
        //for下标反序删除
    /*    System.out.println("=======for反序下标删除========");
        System.out.println("删除前:"+lst.size());
        for (int i = lst.size()-1; i >=0; i--) {
            lst.remove(i);
        }
        System.out.println("删除后:"+lst.size());
        */
        

        //2)迭代器删除
        System.out.println("=======迭代器删除========");
        //hasNext():判断集合中是否有下一个元素
        //next():移动到下一个元素，并取出
        System.out.println("删除前:"+lst.size());
        Iterator s1=lst.iterator();
        while(s1.hasNext()) {//true
            s1.next();
            s1.remove();
        }
        System.out.println("删除后:"+lst.size());
        
        
        //4.List优化
        //初始化容量:10 
        //负载因子(扩容比例):0.5
        //公式:容器大小+10*0.5
        //10+10*0.5=15  11==>15
        //15+10*0.5=20 16==>20
        
        //4.泛型
        List<Integer> lst1=new ArrayList<Integer>(4);//初始量:10
        lst1.add(2);
        lst1.add(1);
        lst1.add(3);
        /*lst1.add("小猪");*/
        
        Iterator<Integer> it=lst1.iterator();
        while(it.hasNext()) {
            /*            Object next=it.next();
            Integer num=Integer.parseInt(next.toString());
*/            
            Integer num = it.next();
            if(num%2==0) {
                System.out.println(num);
            }
        }
        
        //5.装箱和拆箱
        //1)装箱：值类型->引用类型
        int a= 4;
        Integer ina =new Integer(a);
        //2）拆箱:引用类型->值类型
        Integer inb=new Integer(3);
        Float f=new Float(4f);
        int d=inb.intValue();
        
        
    }
}