List（ArrayList与LinkList）以及Set（HashSet，TreeSet，LinkedHashSet）区别以及常用的方法

最新推荐文章于 2024-11-11 00:03:55 发布

如履灬薄冰丿

最新推荐文章于 2024-11-11 00:03:55 发布

阅读量797

点赞数 24

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_64417283/article/details/140720236

版权

List

ArrayList

代码如下：
各个list的特点 ArrayList 的特点，他是有序的（指的是插入的顺序）(也有索引下标)，线性结构
在操作方面因为有序所以查找根据索引查找，查找快，插入慢（慢的原因是因为，每次插入，都会插入位置后面的所有元素后移一个位置）

//    各个list的特点 ArrayList 的特点，他是有序的（指的是插入的顺序）(也有索引下标)，线性结构
//     在操作方面因为有序所以 查找根据索引查找，查找快，插入慢（慢的原因是因为，每次插入，都会插入位置后面的所有元素后移一个位置）
    public static void main(String[] args) {
        List list=new ArrayList();
        System.out.println("==========增==========");
        System.out.println("添加元素");
        list.add("张三");
        list.add(18);
        list.add("打游戏");
        list.add("男");
        System.out.println(list);
        System.out.println("====================删除============================");
        System.out.println("删除指定索引位置元素");
        list.remove(2);
        System.out.println(list);
        System.out.println("=================根据集合删除===================");
        System.out.println("按照集合来删除元素：参数是集合，如果本集合中存在参数集合中的元素，那么删除参数集合中的元素");
        List list1=new ArrayList();
        list1.add(18);
        list1.add("男");

        System.out.println("打印参数集合");
        System.out.println(list1);
        System.out.println("打印本集合");
        System.out.println(list);
        System.out.println("打印删除后的集合");
        list.removeAll(list1);
        System.out.println(list);
        System.out.println("==================改================");
        list1.set(0,"李四");
        System.out.println(list1);
//        注意删除返回的是布尔值

        System.out.println("================查==============");
        System.out.println("返回值为boolean");

        boolean bl=list1.contains("李四");
        System.out.println(bl);
        List list2=new ArrayList<>();
        list2.add("李四");
        list2.add("男");
        System.out.println(list1);
        boolean bl2=list1.containsAll(list2);
        System.out.println(bl2);
        System.out.println("=================集合长度============");
        int size=list1.size();
        System.out.println("list1集合为："+list1);
        System.out.println("打印list1集合大小");
        System.out.println(size);


    }

LinkedList

todo LinkedList 特点：双向链表，有序（按照插入顺序排列，有索引，他的索引是先双向链表遍历之后才赋予的），
因为他的索引是先遍历完链表之后才有的所以查询慢，因为是双线链表插入只需要修改链表指向，所以插入，修改快
和ArrayList的区别查询速度比ArrayList慢，但是插入，修改操作速度比ArrayList快

//todo LinkedList 特点：双向链表，有序（按照插入顺序排列，有索引，他的索引是先双向链表遍历之后才赋予的），
//    因为他的索引是先遍历完链表之后才有的 所以查询慢， 因为是双线链表 插入只需要修改 链表指向，所以插入，修改快
//    和ArrayList的区别  查询速度比ArrayList慢，但是插入，修改操作 速度比ArrayList快
    public static void main(String[] args) {
        List list= new LinkedList();
        List list1=new LinkedList();
        System.out.println("=============增===============");
        list.add("张三");
        list.add(18);
        list.add("打游戏");
        list.add("程序员");
        System.out.println("list="+list);
        list1.add("张三");
        list1.add("北京");
        list1.add("1w薪资");
        System.out.println("按照集合方式增加");
        System.out.println(list1);
        list.addAll(list1);
        System.out.println(list);

//        arraylist中也有addAll，只是没做演示
        System.out.println("=====================删除===================");
        System.out.println("根据索引删除");
        list.remove(2);
        System.out.println("删除索引为2的元素的list="+list);
        System.out.println("根据集合来删除元素；如果本集合中存在参数集合中的元素，那么删除参数集合中的元素");
        System.out.println("list1="+list1);
        list.removeAll(list1);
        System.out.println("根据集合删除后的list="+ list);
        System.out.println("================改===================");
        list.set(0,"王五");
        System.out.println(list);

        System.out.println("=============查=============");
        System.out.println("list="+list);
        System.out.println("list1="+list1);
boolean bl=list.contains("王五");
        System.out.println(bl);List list2=new LinkedList();
        list2.add("王五");
        list2.add("程序员");
        boolean bl2=list.containsAll(list2);
        System.out.println(bl2);
        System.out.println("=============集合大小（长度）===============");
        int size=list.size();
        System.out.println(size);



    }

Set

Hashset

  list已经说完接下来是 Set 类型都有 HashSet，TreeSet，LinkedHashSet，HashSet 无序（指的是不依照插入的顺序排列根据hashcode值排序），唯一性  根据的hash值来进行的排序通过。通过HasHmap实现的唯一性  无序的 线程不安全 允许值为null
代码如下：

 /**  list已经说完接下来是 Set 类型都有 HashSet，TreeSet，LinkedHashSet
     * HashSet 无序（指的是不依照插入的顺序排列根据hashcode值排序），
     * 唯一性  根据的hash值来进行的排序
     * 通过HasHmap实现的唯一性  无序的 线程不安全 允许值为null
     * */
    public static void main(String[] args) {
        Set set=new HashSet();
        Set set1=new HashSet();
        System.out.println("===========增==============");
        set.add("一");
        set.add("二");
        set.add("三");
        set.add("四");
        set.add("五");
        set.add("六");
        System.out.println("注意查看唯一性，代码里面添加了二个六，注意看打印结果。（只有一个六）");
        set.add("六");
        System.out.println("set="+set);
        set1.add("四");
        set1.add("六");
        set1.add("二");
        System.out.println("set1="+set1);
        System.out.println("=============删除=============");
//       因为是无序的所以删除是根据指定的元素删除的
        set.remove("三");
        System.out.println(set);
        System.out.println("参数set1="+set1);
        System.out.println("根据set1集合删除");
        set.removeAll(set1);
        System.out.println(set);
        System.out.println("===========查============");
        System.out.println("是否包含了一");
      boolean bl=  set.contains("一");
        System.out.println(bl);
        System.out.println("set="+set);
        System.out.println("set1"+set1);
      boolean bl2=  set.containsAll(set1);
//      因为他是无序的没有索引 所以无法进行修改
        System.out.println(bl2);
        System.out.println("=======大小=====");
        System.out.println(set.size());

    }

TreeSet

list已经说完接下来是 Set 类型都有 HashSet，TreeSet，LinkedHashSet
 TreeSet 无序（指的是不依照插入的顺序排列根据hashcode值排序） 唯一性
代码如下：

 public static void main(String[] args) {
        /**  list已经说完接下来是 Set 类型都有 HashSet，TreeSet，LinkedHashSet
         * TreeSet 无序（指的是不依照插入的顺序排列根据hashcode值排序） 唯一性
         * */
        Set set= new TreeSet();
        System.out.println("====================增===============");
        set.add("一");
        set.add("二");
        set.add("三");
        System.out.println("set="+set);
        Set set2= new TreeSet();
        set2.add("四");
        set2.add("五");
        set2.add("六");
        System.out.println("set2="+set2);
        System.out.println("把set2添加到set中");
        set.addAll(set2);
        System.out.println("添加完成之后的set为："+set);
        System.out.println("===================删除=================");
        System.out.println("删除set集合中的 四");
        set.remove("四");
        System.out.println("set="+set);
        System.out.println("set2="+set2);
        System.out.println("把set中包含的set2的元素全部删除");
        set.removeAll(set2);
        System.out.println("set="+set);
        System.out.println("============查找=========");
        System.out.println(set.contains("一"));
        System.out.println("查询set2是否还在set中");
        System.out.println(set.containsAll(set2));
        System.out.println("=======大小=====");
        System.out.println(set.size());





    }

LinedHashSet

  list已经说完接下来是 Set 类型都有 HashSet，TreeSet，LinkedHashSet
 LinkedHashSet 哈希表的链接
 HashSet 哈希表的快速查询  ”有序“ 唯一性  注意： 是有序
代码如下：

  /**  list已经说完接下来是 Set 类型都有 HashSet，TreeSet，LinkedHashSet
     * LinkedHashSet 哈希表的链接
     *  HashSet 哈希表的快速查询  ”有序“ 唯一性  注意： 是有序
     * */
    public static void main(String[] args) {
        Set set=new LinkedHashSet();

        System.out.println("========增===========");
        set.add("一");
        set.add("二");
        set.add("三");
        System.out.println("set="+set);
        Set set2=new LinkedHashSet();
        set2.add("四");
        set2.add("五");
        set2.add("六");
        System.out.println("set2="+set2);
        System.out.println("把set2添加到set中");
        set.addAll(set2);
        System.out.println("set="+set);
        System.out.println("====================删除=======================");
        set.remove("四");
        System.out.println("把四从set中删除");
        System.out.println("set="+set);
        System.out.println("把set2中包含的元素从set中删除");
        System.out.println("set2="+set2);
        set.removeAll(set2);
        System.out.println("set="+set);
        System.out.println("==================查=================");
        System.out.println("是否包含一?");
        System.out.println(set.contains("一"));
        System.out.println("是否包含set2?");
        System.out.println(set.contains(set2));
        System.out.println("=======大小=====");
        System.out.println(set.size());




    }

对于List与set的遍历方式：

对于List和Set的遍历问题:
List 首先他是有序的（也就是拥有索引）可以通过for循环（二种增强for与普通for遍历）也可以通过迭代器遍历
List可以的原因是因为里面有一个get方法后续看代码理解吧，
Set 他是无序的，无法通过普通的for循环遍历，可以通过增强for 与迭代器遍历
考虑到后续结果太长所以我吧打印的换行给去掉了我用的是 System.out.print

代码如下：

/** 对于List和Set的遍历问题:
 *      List 首先他是有序的（也就是拥有索引） 可以通过for循环（二种 增强for与普通for遍历） 也可以通过迭代器遍历
 *          List可以的原因是因为里面有一个get方法 后续看代码理解吧，
 *      Set  他是无序的，无法通过普通的for循环遍历，可以通过增强for 与迭代器遍历
 * 考虑到后续结果太长所以我吧打印的换行给去掉了我用的是 System.out.print
*/

    public static void main(String[] args) {
        Set set=new HashSet();
        set.add("一");
        set.add("二");
        set.add("三");
        set.add("四");
        set.add("五");
        set.add("六");
        System.out.println(set);
        List list= new LinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        System.out.println(list);
//        先遍历 list
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
//        换行作用
        System.out.println();
//    增强for  此处Object的原因是因为我没有规定泛型，默认为Object 所以这里要用Object
//        如果想用int（会自动进行自动包装和拆箱） 定义的时候可以这样定义 List<Integer> list= new LinkedList();
//        注意泛型 不允许定义为基本类型 所以这里用了 int 的包装类型
        for (Object num: list) {

            System.out.print(num);
        }
        System.out.println();
//        迭代器遍历
        Iterator It=list.iterator();
        while (It.hasNext()){
          Object  num= It.next();
            System.out.print(num);
        }
        System.out.println();
        System.out.println("接下来遍历set集合");
//        这里Object和前面同理 只是因为没有定义泛型而已所以默认为Object了
        for (Object str:set) {
            System.out.print(str);
        }
        System.out.println();
        Iterator It2= set.iterator();
        while (It2.hasNext()){
            Object str=It2.next();
            System.out.print(str);
        }

    }