SeventeenDay-java Collection的子类及其实现类

1、取迭代器的注意事项

注意：一旦集合结构发生改变，迭代器必须重新获取

public static void main(String[] args) {
    Collection c=new ArrayList();
    /*
    此处的迭代器，指向的是集合中没有元素的状态。
    注意：一旦集合结构发生改变，迭代器必须重新获取
    若没有重新获取 则在调用next()方法时 会出现ConcurrentModificationException的异常
     */
　　//获取迭代器
    Iterator it=c.iterator();
    c.add(1);//c中存放的是 new Integer(1);内存地址
    c.add(3);
    c.add("4");

    while(it.hasNext()){
        Object obj=it.next();//返回类型必须是Object类型
        System.out.println(obj);
    }
}

2、remove

当迭代删除元素的时候，要使用迭代器删除元素

Iterator it=c.iterator();
while(it.hasNext()){
    Object obj=it.next();//返回类型必须是Object类型
    /*通过集合去删除元素，删除的是集合中的元素，而迭代器快照中并没有更新，会出现ConcurrentModificationException的异常
     */
    //c.remove(obj);
    it.remove();//通过迭代器删除当前指向元素，会自动更新迭代器，并且更新集合（删除集合中的元素）
    System.out.println(obj);
}

3、List中常用方法

List特点：可重复有序，有序是指存入的顺序与取出的顺序一样

List接口继承Collection接口，除继承父类方法还有自己独有的方法：

　　void add(int index, E element);

　　E get(int index)

　　int indexOf(Object o)

　　int lastIndexOf(Object o)

　　E set(int index, E element)

　　E remove(int index)

public static void main(String[] args) {
    //创建List类型的集合
    List mylist=new ArrayList();
    //添加元素 默认添加到集合末尾
    mylist.add("w");
    mylist.add("a");
    mylist.add("j");
    //添加元素到指定位置
    mylist.add(1,"a");
    //取迭代器
    Iterator o=mylist.iterator();
    //迭代
    while(o.hasNext()){
        Object obj=o.next();
        System.out.print(obj+" ");//w a a j
    }
    System.out.println("\n========");
    //返回元素第一次出现的下标，最后出现的下标
    System.out.println(mylist.indexOf("a"));//1
    System.out.println(mylist.lastIndexOf("a"));//2
    //删除指定下标的元素
    System.out.println(mylist.remove(1));//a
    //用指定的元素替代指定位置上的元素
    System.out.println(mylist.set(0,"s"));//返回的是被替代元素 w
    //根据下标遍历集合
    for (int i = 0; i < mylist.size(); i++) {
        System.out.print(mylist.get(i)+" ");//s a j
    }

}

4、ArrayList集合

List的实现类

默认初始化容量为10；(底层先创建一个空数组，当添加第一个元素的时候，容量为10)
集合底层是Object[]数组
构造方法： new ArrayList(); new ArrayList(20);
集合扩容：集合满了后（底层数组满了）每次扩容原容量的1.5倍
优点：检索效率高（每个元素所占内存空间一样，空间地址连续）
缺点：随机增删元素效率低，无法存储大数据量，很难找到一块大的连续空间
不是线程安全的

//Array List 的构造方法代码
public static void main(String[] args) {
    //初始化容量为10，元素个数为0
    List list1=new ArrayList();
    //初始化容量为20，元素个数为0
    List list2=new ArrayList(20);
    //创建一个HashSet集合
    Collection c=new HashSet();
    c.add(100);
    c.add(200);
    c.add(300);
    List list3=new ArrayList(c);
    System.out.println(list3.size());//3
}

5、LinkedList集合

List的实现类

链表的优点：由于链表在内存中存储的地址不连续，所以随机增删不会发生大量元素位移，因此增删效率较高

缺点：由于内存地址不连续，每次检索都要从头节点开始，所以检索效率较低

public static void main(String[] args) {
    /*
    LinkedList集合底层是双向链表。
     */
    List list=new LinkedList();
    list.add("12");
    list.add("as");
    list.add(10);
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

补充：

//把ArrayList非线程安全转换成线程安全
//使用工具类Java.util.Collections(注意Java.util.Collection是集合接口)
List mylist=new ArrayList();
Collections.synchronizedList(mylist);//把mylist变为线程安全的

6、Vector集合

实现List接口，与ArrayList,LinkedList用法一样。

Vector:

　　底层也是一个数组

　　初始化容量10

　　扩容是原容量的两倍

　　所有方法都是线程同步的

　　是线程安全的，效率较低，使用较少

public static void main(String[] args) {
    List list=new Vector();
    list.add("qw");
    list.add("12");
    //获取迭代器
    Iterator it=list.iterator();
    //迭代
    while(it.hasNext()){
        Object obj=it.next();
        System.out.println(obj);
    }
 }

7、自定义泛型

自定义泛型的时候，<>尖括号里面是一个标识符，随便写

最常用的是<E>,<T> E:是Element单词首字母。 T:是Type单词首字母

public class GenericTest03<A> {
    public static void main(String[] args) {
        GenericTest03<String> g=new GenericTest03<>();
        g.doSome("12");//规定了A为String类型 调用doSome方法是传参类型必须是String类型
        String s=g.getSome();//A为String类型，故返回类型也为string
        GenericTest03<Integer> I=new GenericTest03<>();
        I.doSome(12);//规定了A为Integer类型 调用doSome方法传参类型必须是Integer类型
        int i=I.getSome();//A为int类型，故返回类型为int
        //不用泛型
        GenericTest03 g1=new GenericTest03();
        Object obj=g1.getSome();//不用泛型，返回类型就是Object

    }
    public void doSome(A o){
        System.out.println("泛型");
    }
    public A getSome(){
        return null;
    }
}

8、HashSet

Set接口的实现类

HashSet：无序不可重复，底层调用HashMap

存放在HashSet的元素实际上是放在HashMap的key部分了

public static void main(String[] args) {
    Set<String> s=new HashSet<>();
    s.add("12");
    s.add("12");
    s.add("12");
    s.add("234");
    s.add("123");
    System.out.println(s.size());//3 数据不可重复
    //遍历
    for (String s1 : s) {
        System.out.println(s1);//输出来的顺序与存放的顺序不一定一样
    }
}

9、TreeSet

SortedSet接口的实现类（SortedSet继承Set接口）

TreeSet:无序不可重复但是元素会自动按大小排序称可排序集合

public static void main(String[] args) {
    Set<String> s=new TreeSet<>();
    s.add("4");
    s.add("a");
    s.add("6");
    s.add("a");
    for (String s1 : s) {
        System.out.print(s1+" ");//4 6 a
    }
}

10、自动类型判断机制（钻石表达式）

public static void main(String[] args) {
    //JDK8之后 ArrayList<>这里可以省略不写 程序自动识别
    List<Animal> mylist=new ArrayList<>();
}

posted @ 2021-07-09 18:27 别不开心，过得去阅读(100) 评论(0) 收藏举报

刷新页面返回顶部

SeventeenDay-java Collection的子类及其实现类

公告