Java重点 | Collection集合的子类

Collection集合的子类

List接口独有的常用方法

举例介绍

public class List接口常用方法 {
    public static void main(String[] args) {
        List list = new ArrayList();

        list.add("aa");
        list.add("bb");
        //add()在列表的指定位置上插入指定元素(第一个参数是下标)
        //这个方法使用不多，因为对于ArrayList集合来说效率不较
        list.add(1,"cc");

        //get()根据下标获取元素
        Object o = list.get(1);
        System.out.println(o);//cc

        //因为有下标，所以List集合有自己比较特殊的遍历方式
        //通过下标遍历。【List集合特有的方式，Set没有】
        for (int i = 0; i < list.size(); i++) {
            Object o1 = list.get(i);
            System.out.println(o1); //aa cc bb
        }

        //indexOf 获取指定对象第一次出现的索引
        int index = list.indexOf("cc");
        System.out.println(index); //1

        //lastIndexOf 获取指定对象最后一次出现的索引
        int index1 = list.lastIndexOf("bb");
        System.out.println(index1); //2

        System.out.println("======================");
        //remove：删除指定下标位置的元素。
        list.remove(0);
        for (int i = 0; i < list.size(); i++) {
            Object o1 = list.get(i);
            System.out.println(o1); // cc bb
        }

        //set：修改指定位置的元素
        list.set(1,"aaa");

        System.out.println("======================");

        for (int i = 0; i < list.size(); i++) {
            Object o1 = list.get(i);
            System.out.println(o1); // cc aaa
        }


    }
}

ArratList集合介绍

三种构造方法

/**
 * 三种构造方法
 */

public class ArratList集合 {
    public static void main(String[] args) {
        //无参构造 默认初始化容量为10
        List list = new ArrayList();

        //有参构造更改初始化容量为20
        List list1 = new ArrayList(20);

        //创建一个HashSet集合
        Collection c =new HashSet();
        c.add(1);
        c.add(2);
        c.add(6);
        c.add(4);

        //通过这个构造方法 可以将HashSet集合转换成List集合
        List list2 =new ArrayList(c);
        for (int i =0;i<list2.size();i++){
            System.out.println(list2.get(i));
        }
    }
}

LinkedList集合

链表的优缺点

常用方法

private static void domed01() {
        /*
            public void addFirst(E w):将指定元素添加到此列表的开头 此方法等效push
            public void addLast(E e):将指定元素添加到此列表的结尾  此方法等效于add
            public void push(E e):将元素推入此列表所表示发堆栈 此方法等效addFirst
         */

        // 创建LinkedList
        LinkedList<String> lin = new LinkedList<String>();
        // 使用add方法往集合添加元素
        lin.add("a");
        lin.add("b");
        lin.add("c");
        System.out.println(lin); // [a, b, c]

        //public void addFirst(E w):将指定元素添加到此列表的开头 此方法等效push
//        lin.addFirst("www");
        lin.push("www");
        System.out.println(lin); //[www, a, b, c]

        //public void addLast(E e):将指定元素添加到此列表的结尾 此方法等效于add
        lin.addLast("com");
        System.out.println(lin);//[www, a, b, c, com]
    }

    private static void domed02() {
        /*
            public E getFirst():返回此列表第一个元素
            public E getLast():返回此列表最后一个元素
         */

        // 创建LinkedList
        LinkedList<String> lin = new LinkedList<String>();
        // 使用add方法往集合添加元素
        lin.add("a");
        lin.add("b");
        lin.add("c");

//        lin.clear(); //清空集合中的元素，在获取集合中的元素会抛出NoSuchElementException
        //添加判断
        // public boolean isEmpty(): 如果列表不包含元素，则返回ture ；空的返回ture
        if (!lin.isEmpty()) { //!lin.isEmpty()添加取反，不是空的返回ture，才执行；是空的就不获取了
            String first = lin.getFirst();
            System.out.println(first); //a
            String last = lin.getLast();
            System.out.println(last); //c
        }

    }

    private static void domed03() {
        /*
            public E removeFirst(): 移除并返回此列表的第一个元素
            public E removeLast()：移除并返回此列表的最后一个元素
            public E pop(): 从此列表所表示的堆栈处弹出一个元素。此方法相当于removeFirst
         */

        // 创建LinkedList
        LinkedList<String> lin = new LinkedList<String>();
        // 使用add方法往集合添加元素
        lin.add("a");
        lin.add("b");
        lin.add("c");
        System.out.println(lin); // [a, b, c]

        String s = lin.removeFirst();
//        String pop = lin.pop();
        System.out.println("被移除的以一个元素："+s); //被移除的以一个元素：a
        String s1 = lin.removeLast();
        System.out.println("被移除的最后一个元素："+s1); //被移除的最后一个元素：c
    }

Vector集合

HashSet集合

代码示例

public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        //使用add方法添加元素
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);
        System.out.println(set); //[1, 2, 3]

        //使用迭代器遍历
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()){
            Integer next = iterator.next();
            System.out.println(next);
        }

        //使用增强for
        for (Integer integer : set) {
            System.out.println(integer);
        }
    }

TreeSet集合

可变参数

代码示例

 public static void main(String[] args) {
//        int i = add();
//        int i = add(10);
//        int i = add(10,20);
        int i = add(10,20,30,40,50,60,70,80,90,100);
        System.out.println(i);
        aa(1,2.3,"iws");
    }
    /*
        定义计算（0-n）个整数和的方法
        已知：计算整数的和，数据类型已经确定int
        但是参数的个数不确定，不知道要计算几个整数的和，就可以使用可变参数

        调用add();方法，就会创建一个长度为0的数组，new int[0]
        调用add(10);方法，就会创建一个长度为1的数组，存储传递过来的参数 new int[]{10};
        调用add(10,20);方法，就会创建一个长度为2的数组，存储传递过来的参数 new int[]{10,20};
        调用add(10,20,30,40,50,60,70,80,90,100);方法，就会创建一个长度为10的数组，存储传递过来的参数
        new int[]{10,20,30,40,50,60,70,80,90,100};

        add(10);
     */
    public static int add(int...arr){
//        System.out.println(arr); //[I@7c30a502 底层是一个数组
//        System.out.println(arr.length);//0,1,2,10
        //定义一个初始化变量，记录累加和求和
        int sum = 0;
        //遍历数组，获取数组中的每一个元素
        for (int i : arr) {
            sum+=i;
        }
        //把求和结果返回
        return sum;
    }
    //可变参数终极写法
    public static void aa(Object...obj){
        System.out.println(obj.length);
    }
}