Java学习_20220613

Java集合框架

1. 集合概念：对象的容器，实现了对对象常用的操作，类似数组功能。

和数组的区别：

• 数组长度固定，集合长度不固定；
• 数组可以存储基本类型和引用类型，集合只能存储引用类型（要存储基本类型，则进行装箱操作。）

2. Collection体系集合

（1）添加元素

//Collection不能被实例化，可以创建对象 ArrayList 实现了Collection
Collection collection = new ArrayList();
//添加元素
collection.add("A");
collection.add("B");
collection.add("Z");
System.out.println("元素个数："+collection.size());
System.out.println(collection);

//例如保存学生信息：（1）Student类两个属性name\age
//(2)实例化 Student s1 = new Student("张三",12);
//（3）保存 collection.add(s1);

（2）删除元素

collection.remove("A");//collection.remove(s1);
System.out.println(collection);

（3）遍历元素

//遍历元素：1.增强for  2.使用迭代器（迭代器专门用来遍历集合的一种方式）
for (Object o : collection){
    System.out.println("元素为："+o);
}
Iterator it = collection.iterator();
while (it.hasNext()){
    System.out.println(it.next());//Student s = (Student)it.next();
    //不能使用collection删除方法（collection.remove(it.next());）
    it.remove();
}

（4）判断是否存在，是否为空

//判断
System.out.println(collection.contains("B"));
System.out.println(collection.isEmpty());

3. List子接口：继承了Collection有序、有下标、元素可重复

（1）添加

List list = new ArrayList();
list.add("苹果");
list.add("香蕉");
list.add("草莓");
list.add("橘子");
list.add(0,"s");//在索引为0处增加一个元素
System.out.println(list);

（2）删除（与collections一致）

（3）遍历

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}
for(Object ob : list){
    System.out.println(ob);
}

Iterator it = list.iterator();
while (it.hasNext()){
    System.out.println(it.next());
}
//使用列表迭代器ListIterator，
// 和LIterator的区别：ListIterator可以向前或者向后遍历。添加、删除、修改元素
ListIterator listIterator = list.listIterator();
//使用listIterator从前往后
while (listIterator.hasNext()){ //listIterator.nextIndex()下一个角标
    System.out.println(listIterator.nextIndex()+":"+listIterator.next());
}
//使用listIterator从后往前
while (listIterator.hasPrevious()){ //listIterator.previousIndex()前一个角标
    System.out.println(listIterator.previousIndex()+":"+listIterator.previous());
}

（4）判断（一致）

（5）获取

System.out.println(list.indexOf("草莓"));

若保存的是数字，则自动完成装箱过程

删除：list.remove(new Integer(10));或者list.remove((Object)10);

//sublist返回子集合，含头不含尾
List sub = list.subList(2, 4);
System.out.println(sub.toString());

 

 List实现类：

（1）ArrayList：数组结构实现，查询快、增删慢，运行快，线程不安全，必须开辟连续空间

  默认容量DEFULT_CAPACITY = 10;

  （没有向集合中添加任何元素时，容量为0，添加一个元素后，容量为10，每次扩容大小是原来的1.5倍）

  存放元素的数组elementData；

  实际个数：size

（2）Vector：数组结构实现，查询快、增删慢，运行慢，线程安全

（用枚举器遍历）

（3）LinkedList：链表结构实现，增删快，查询慢，无需开辟连续空间，node

LinkedList linkedList = new LinkedList();
//添加、删除、遍历与ArrayList()方法一样

重写equals：public boolean equals(Object obj){

}

4. 泛型

本质是参数化类型，把类型作为参数传递。

（1）泛型类

//泛型类，语法，类名<T>
//T是类型占位符，表示一种引用类型，若编写多个使用,隔开
public class MyCeneric<T> {
    T t;//使用泛型T，创建变量
    //泛型作为方法的参数
    public void show(T t){
        System.out.println(t);
    }
    public void setT(T t) {
        this.t = t;
    }
    //泛型作为方法的返回值
    public T getT() {
        return t;
    }
}
public class Ceneric_test {
    public static void main(String[] args) {
        //使用泛型类创建对象
        //注意：1.泛型只能使用引用类型；2.不同泛型对象不能相互复制
        MyCeneric<String> stringMyCeneric = new MyCeneric<>();
        stringMyCeneric.t="我是泛型";
        stringMyCeneric.show(stringMyCeneric.t);//我是泛型
        stringMyCeneric.show("万恶之源");//万恶之源
        stringMyCeneric.setT("ping");
        stringMyCeneric.show(stringMyCeneric.t);//ping
        String s = stringMyCeneric.getT();
        System.out.println(s);//ping
        //2.不同泛型对象不能相互复制  
        //MyCeneric<Integer> stringMyCeneric2 = stringMyCeneric; 出错
    }
}

2. 泛型接口

/**
 * 泛型接口，接口名<T>
 *     注意：不能定义静态常量
 * @param <T>
 */
public interface InterfaceGeneric<T> {
    String name = "张三";

    T server(T T);
}
//实现1
public class InterGenericImpl implements InterfaceGeneric<String>{
    @Override
    public String server(String t) {
        System.out.println(t);
        return t;
    }
}
//调用
InterGenericImpl ing = new InterGenericImpl();
ing.server("cccccc");

//实现2
public class InterGenericImpl<T> implements InterfaceGeneric<T>{
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}
//调用
 InterGenericImpl<Integer> ing = new InterGenericImpl();
 ing.server(1000);