Java的集合框架，Collection、Vector、Iterator、Set、LinkedList、Arrays

最新推荐文章于 2024-07-09 16:46:46 发布

Only hand ripe

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量85

点赞数

文章标签： java collection set list iterator

本文链接：https://blog.csdn.net/qq_38592706/article/details/109904704

版权

CollectionDemo

java集合框架：
Collection：存放的是单一值
特点：
1、可以存放不同类型的数据，而数组只能存放固定类型的数据
2、当使用arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作
api方法：
增加数据的方法
add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程
addAll:添加另一个集合的元素到此集合中

       删除数据的方法
       clear:只是清空集合中的元素，但是此集合对象并没有被回收
       remove:删除指定元素
       removeAll：删除集合元素

      查询数据的方法
       contains:判断集合中是否包含指定的元素值
      containsAll:判断此集合中是否包含另一个集合
      isEmpty:判断集合是否等于空
       retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
       size:返回当前集合的大小

       //集合转数组的操作
     toArray:将集合转换成数组

/**
 * @author: 马士兵教育
 * @create: 2019-09-07 21:21
 */
/*
* java集合框架：
*   Collection：存放的是单一值
*       特点：
*           1、可以存放不同类型的数据，而数组只能存放固定类型的数据
*           2、当使用arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作
*       api方法：
*           增加数据的方法
*           add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程
*           addAll:添加另一个集合的元素到此集合中
*
*           删除数据的方法
*           clear:只是清空集合中的元素，但是此集合对象并没有被回收
*           remove:删除指定元素
*           removeAll：删除集合元素
*
*           查询数据的方法
*           contains:判断集合中是否包含指定的元素值
*           containsAll:判断此集合中是否包含另一个集合
*           isEmpty:判断集合是否等于空
*           retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
*           size:返回当前集合的大小
*
*           //集合转数组的操作
*           toArray:将集合转换成数组
* */
public class CollectionDemo {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(1);
        collection.add(true);
        collection.add(1.23);
        collection.add("abc");
        System.out.println(collection);
        ((ArrayList) collection).add(0,"mashibing");
        System.out.println(collection);
        Collection collection1 = new ArrayList();
        collection1.add("a");
        collection1.add("b");
        collection1.add("c");
        collection1.add("d");
        collection.addAll(collection1);
        System.out.println(collection);
//        collection.clear();
//        System.out.println(collection);
        System.out.println(collection.contains("a"));
        System.out.println(collection.containsAll(collection1));
        System.out.println(collection.isEmpty());
//        collection.remove("a");
//        System.out.println(collection);
        System.out.println(collection1.retainAll(collection));
        Object[] objects = collection.toArray();
        collection.add("a");
        System.out.println(collection);


    }
}

CollectionsDemo

package com.mashibing;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @author: 马士兵教育
 * @create: 2019-09-22 15:04
 */
public class CollectionsDemo {
    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("af");
        list.add("bg");
        list.add("acssf");
        list.add("bdfsdfsd");

        Collections.addAll(list,"cefsdf","cf1","cg32");
        System.out.println(list);

//        list.sort(new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                if(o1.length()>o2.length()){
//                    return 1;
//                }else if(o1.length()<o2.length()){
//                    return -1;
//                }else{
//                    return 0;
//                }
//            }
//        });
//        System.out.println(list);
//
//        Collections.sort(list);
//        Collections.sort(list,new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                if(o1.length()>o2.length()){
//                    return 1;
//                }else if(o1.length()<o2.length()){
//                    return -1;
//                }else{
//                    return 0;
//                }
//            }
//        });
//        System.out.println(list);

        //二分查找的时候需要先进行排序操作，如果没有排序的话，是找不到指定元素的
        Collections.sort(list);
        System.out.println(Collections.binarySearch(list,"acssf"));

        Collections.fill(list,"mashibing");
        System.out.println(list);
    }
}

ArraysDemo

Arrays提供了数据操作的工具类，包含很多方法
集合和数组之间的转换
数组转成list：

package com.mashibing;

/**
 * @author: 马士兵教育
 * @create: 2019-09-22 15:16
 */

import java.util.Arrays;
import java.util.List;

/**
 * Arrays提供了数据操作的工具类，包含很多方法
 *      集合和数组之间的转换
 *          数组转成list：
 *
 *
 */
public class ArraysDemo {
    public static void main(String[] args) {
//        int[] array = new int[]{1,2,3,4,5};
        List<Integer> ints = Arrays.asList(1,2,3,4,5);

        //list转换成数组
        Object[] objects = ints.toArray();
    }
}

LinkedListDemo

package com.mashibing;

import java.util.LinkedList;

/**
 * @author: 马士兵教育
 * @create: 2019-09-08 15:18
 */
/*
* linkedList拥有更加丰富的方法实，需要用的时候查询api即可，不需要记忆
*
* */
public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(123);
        linkedList.add(false);
        linkedList.add("abc");
        System.out.println(linkedList);
        linkedList.add(2,"mashibing");
        System.out.println(linkedList);
        linkedList.addFirst("1111");
        System.out.println(linkedList);
        linkedList.addLast("2222");
        System.out.println(linkedList);
        System.out.println(linkedList.element());
        linkedList.offer("3333");
        System.out.println(linkedList);


    }
}

ListDemo

java集合框架：
List：存放的是单一值
特点：
1、可以存放不同类型的数据，而数组只能存放固定类型的数据
2、当使用arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作
api方法：
增加数据的方法
add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程
addAll:添加另一个集合的元素到此集合中

       删除数据的方法
       clear:只是清空集合中的元素，但是此集合对象并没有被回收
       remove:删除指定元素
       removeAll：删除集合元素

       查询数据的方法
       contains:判断集合中是否包含指定的元素值
       containsAll:判断此集合中是否包含另一个集合
       isEmpty:判断集合是否等于空
       retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
       size:返回当前集合的大小

       //集合转数组的操作
       toArray:将集合转换成数组

package com.mashibing;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * @author: 马士兵教育
 * @create: 2019-09-07 21:21
 */
/*
* java集合框架：
*   List：存放的是单一值
*       特点：
*           1、可以存放不同类型的数据，而数组只能存放固定类型的数据
*           2、当使用arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作
*       api方法：
*           增加数据的方法
*           add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程
*           addAll:添加另一个集合的元素到此集合中
*
*           删除数据的方法
*           clear:只是清空集合中的元素，但是此集合对象并没有被回收
*           remove:删除指定元素
*           removeAll：删除集合元素
*
*           查询数据的方法
*           contains:判断集合中是否包含指定的元素值
*           containsAll:判断此集合中是否包含另一个集合
*           isEmpty:判断集合是否等于空
*           retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
*           size:返回当前集合的大小
*
*           //集合转数组的操作
*           toArray:将集合转换成数组
* */
public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add(1);
        list.add("a");
        list.add(true);
        System.out.println(list);
//        System.out.println(list.get(3));
        System.out.println(list.indexOf("a"));
        System.out.println(list.lastIndexOf("a"));
        list.set(0,"mashibing");
        System.out.println(list);
        List list1 = list.subList(0, 2);
        System.out.println(list1);
//        List of = List.of(1,2,3,4);
//        System.out.println(of);
    }
}

ListTest

package com.mashibing;

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

/**
 * @author: 马士兵教育
 * @create: 2019-09-08 16:30
 */
public class ListTest {
    public static void main(String[] args) {

        List list = new ArrayList();
        Dog d1 = new Dog("大黄","red");
        Dog d2 = new Dog("二黄","block");
        Dog d3 = new Dog("三黄","green");
        list.add(d1);
        list.add(d2);
        list.add(d3);
        System.out.println(list);
        System.out.println(list.size());
        list.remove(d1);
        System.out.println(list);
        Dog d4 = new Dog("二黄","block");
        System.out.println(list.contains(d4));

    }
}

SetDemo

1、set中存放的是无序，唯一的数据
2、set不可以通过下标获取对应位置的元素的值，因为无序的特点
3、使用treeset底层的实现是treemap,利用红黑树来进行实现
4、设置元素的时候，如果是自定义对象，会查找对象中的equals和hashcode的方法，如果没有，比较的是地址
5、树中的元素是要默认进行排序操作的，如果是基本数据类型，自动比较，如果是引用类型的话，需要自定义比较器
比较器分类：
内部比较器
定义在元素的类中，通过实现comparable接口来进行实现
外部比较器
定义在当前类中，通过实现comparator接口来实现，但是要将该比较器传递到集合中
注意：外部比较器可以定义成一个工具类，此时所有需要比较的规则如果一致的话，可以复用，而
内部比较器只有在存储当前对象的时候才可以使用
如果两者同时存在，使用外部比较器
当使用比较器的时候，不会调用equals方法

package com.mashibing;

import java.util.*;

/**
 * @author: 马士兵教育
 * @create: 2019-09-08 16:36
 */
/*
*   1、set中存放的是无序，唯一的数据
*   2、set不可以通过下标获取对应位置的元素的值，因为无序的特点
*   3、使用treeset底层的实现是treemap,利用红黑树来进行实现
*   4、设置元素的时候，如果是自定义对象，会查找对象中的equals和hashcode的方法，如果没有，比较的是地址
*   5、树中的元素是要默认进行排序操作的，如果是基本数据类型，自动比较，如果是引用类型的话，需要自定义比较器
*       比较器分类：
*         内部比较器
*               定义在元素的类中，通过实现comparable接口来进行实现
*         外部比较器
*               定义在当前类中，通过实现comparator接口来实现，但是要将该比较器传递到集合中
*         注意：外部比较器可以定义成一个工具类，此时所有需要比较的规则如果一致的话，可以复用，而
*               内部比较器只有在存储当前对象的时候才可以使用
*               如果两者同时存在，使用外部比较器
*               当使用比较器的时候，不会调用equals方法
* */
public class SetDemo implements Comparator<Person> {
    public static void main(String[] args) {
//        Set set = new HashSet();
//        set.add("123");
//        set.add(1);
//        set.add(true);
//        set.add("123");
//        System.out.println(set);
//        Iterator iterator = set.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        System.out.println("---------");
//        //将while循环改成for循环,推荐使用
//        for(Iterator iter = set.iterator(); iter.hasNext();){
//            System.out.println(iter.next());
//        }

//        TreeSet treeSet = new TreeSet();
//        treeSet.add(34);
//        treeSet.add(1);
//        treeSet.add(65);
//        System.out.println(treeSet.ceiling(1));
//        System.out.println(treeSet);
//        HashSet hashSet = new HashSet();
//        hashSet.add(new Person("zhangsan",12));
//        hashSet.add(new Person("zhangsan",12));
//        hashSet.add(new Person("lisi",13));
//        System.out.println(hashSet);

        TreeSet treeSet = new TreeSet(new SetDemo());
        treeSet.add(new Person("lisi",15));
        treeSet.add(new Person("wangwu",13));
        treeSet.add(new Person("maliu",12));
        treeSet.add(new Person("zhangsan",19));
        treeSet.add(new Person("zhangsan",12));
        System.out.println(treeSet);


    }

    @Override
    public int compare(Person o1, Person o2) {
        if(o1.getAge()>o2.getAge()){
            return -1;
        }else if(o1.getAge() < o2.getAge()){
            return 1;
        }else{
            return 0;
        }
    }
}

VectorDemo

   1、Vector也是List接口的一个子类实现
   2、Vector跟ArrayList一样，底层都是使用数组进行实现的
   3、面试经常问区别：
       （1）ArrayList是线程不安全的，效率高，Vector是线程安全的效率低
       （2）ArrayList在进行扩容的时候，是扩容1.5倍，Vector扩容的时候扩容原来的2倍

package com.mashibing;

import java.util.Vector;

/**
 * @author: 马士兵教育
 * @create: 2019-09-08 15:34
 */
/**
 *      1、Vector也是List接口的一个子类实现
 *      2、Vector跟ArrayList一样，底层都是使用数组进行实现的
 *      3、面试经常问区别：
 *          （1）ArrayList是线程不安全的，效率高，Vector是线程安全的效率低
 *          （2）ArrayList在进行扩容的时候，是扩容1.5倍，Vector扩容的时候扩容原来的2倍
 *
 * */
public class VectorDemo {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add(1);
        vector.add("abc");
        System.out.println(vector);
    }
}

IteratorDemo

在java代码中包含三种循环的方式
do…while
while
for
还有一种增强for循环的方式，可以简化循环的编写

所有的集合类都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，也就是for-each
增强for循环本质上使用的也是iterator的功能
方法：
iterator()
foreach()
在iterator的方法中，要求返回一个Iterator的接口子类实例对象
此接口中包含了
hasNext()
next()

在使用iterator进行迭代的过程中如果删除其中的某个元素会报错，并发操作异常，因此
如果遍历的同时需要修改元素，建议使用listIterator（），
ListIterator迭代器提供了向前和向后两种遍历的方式
始终是通过cursor和lastret的指针来获取元素值及向下的遍历索引
当使用向前遍历的时候必须要保证指针在迭代器的结果，否则无法获取结果值

package com.mashibing;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
 在java代码中包含三种循环的方式
*   do...while
*   while
*   for
* 还有一种增强for循环的方式，可以简化循环的编写
*
*
*   所有的集合类都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，也就是for-each
*      增强for循环本质上使用的也是iterator的功能
*      方法：
*               iterator()
*               foreach()
*   在iterator的方法中，要求返回一个Iterator的接口子类实例对象
*       此接口中包含了
*               hasNext()
*               next()
*
*   在使用iterator进行迭代的过程中如果删除其中的某个元素会报错，并发操作异常，因此
*       如果遍历的同时需要修改元素，建议使用listIterator（），
*   ListIterator迭代器提供了向前和向后两种遍历的方式
*       始终是通过cursor和lastret的指针来获取元素值及向下的遍历索引
*       当使用向前遍历的时候必须要保证指针在迭代器的结果，否则无法获取结果值
* */
/**
 * @author: 马士兵教育
 * @create: 2019-09-08 15:42
 */
/*
* 在java代码中包含三种循环的方式
*   do...while
*   while
*   for
* 还有一种增强for循环的方式，可以简化循环的编写
*
*
*   所有的集合类都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，也就是for-each
*      增强for循环本质上使用的也是iterator的功能
*      方法：
*               iterator()
*               foreach()
*   在iterator的方法中，要求返回一个Iterator的接口子类实例对象
*       此接口中包含了
*               hasNext()
*               next()
*
*   在使用iterator进行迭代的过程中如果删除其中的某个元素会报错，并发操作异常，因此
*       如果遍历的同时需要修改元素，建议使用listIterator（），
*   ListIterator迭代器提供了向前和向后两种遍历的方式
*       始终是通过cursor和lastret的指针来获取元素值及向下的遍历索引
*       当使用向前遍历的时候必须要保证指针在迭代器的结果，否则无法获取结果值
* */
public class IteratorDemo {
    public static void main(String[] args) {
        ArrayList list= new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
//        for(int i=0;i<list.size();i++){
//            System.out.println(list.get(i));
//        }

        //迭代器
//        Iterator iterator = list.iterator();
        ListIterator iterator = list.listIterator();
        while(iterator.hasNext()){
            Object o = iterator.next();
            if(o.equals(1)){
                iterator.remove();
            }
            System.out.println(o);
        }
        System.out.println("-------------");
        while (iterator.hasPrevious()){
            System.out.println(iterator.previous());
        }
//        for(Object i : list){
//            System.out.println(i);
//        }
    }
}

Dog

package com.mashibing;

import java.util.Objects;

/**
 * @author: 马士兵教育
 * @create: 2019-09-08 16:29
 */
public class Dog {
    private String name;
    private String color;

    public Dog(){

    }

    public Dog(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Dog dog = (Dog) o;
        return Objects.equals(name, dog.name) &&
                Objects.equals(color, dog.color);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, color);
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

Person

package com.mashibing;

import java.util.Objects;

/**
 * @author: 马士兵教育
 * @create: 2019-09-21 15:32
 */
public class Person implements Comparable{
    private String name;
    private int age;

    public Person(){

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    /**
     * 此比较器按照name的长度来进行比较
     * @param o
     * @return
     */
    @Override
    public int compareTo(Object o) {
        Person p  = (Person) o;
        if (p.name.length()>this.name.length()){
            return -1;
        }else if(p.name.length()<this.name.length()){
            return 1;
        }else{
            return 0;
        }
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Only hand ripe

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java的集合框架，Collection、Vector、Iterator、Set、LinkedList、Arrays

CollectionDemopackage com.mashibing;import java.util.ArrayList;import java.util.Collection;/** * @author: 马士兵教育 * @create: 2019-09-07 21:21 *//** java集合框架：* Collection：存放的是单一值* 特点：* 1、可以存放不同类型的数据，而数组只能存放固定类型的数据* 2
复制链接

扫一扫