Java技术复习提升 12集合

于 2024-11-24 21:13:19 发布
阅读量1k 收藏 8
点赞数 14
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_60566743/article/details/144012096
版权

写在前面：本章涉及到开发常用的集合类讲解 每种集合类常用方法 以及代码实战 篇幅相对较大 望大家耐下心来 扎扎实实掌握知识 祝好~

第12章 集合

12.1 集合的理解和框架

集合的框架体系

集合主要分为两大类 单列集合Collection和双列集合Map Collection分为List和Set List分为ArrayList Linkedlist Vector Set分为Treeset和HashSet；Map分为HashMap TreeMap Hashtable HashMap子类有LinkedHashMap Hashtable子类有Properties

12.2 Collection接口

常用方法：

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

public class Test {
    public static void main(String[] args) {
        List list=new ArrayList();
        List list1=new ArrayList();
        list.add(10);
        list.add("byx");
        list.add(true);
        list.add(list1);

        System.out.println(list);

        list.remove(0);//索引
        list.remove(true);
        list.remove("byx");

        System.out.println(list.contains(10));

        System.out.println(list.isEmpty());

        System.out.println(list);

        list.addAll(list1);

        System.out.println(list);

        list.removeAll(list1);

        System.out.println(list);


    }
}

 

接口遍历元素方式：

1 使用Iterator迭代器

2 for循环增强

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

public class Test {
    public static void main(String[] args) {
        List list=new ArrayList();
        List list1=new ArrayList();
        list.add(10);
        list.add("byx");
        list.add(true);
        list.add(list1);

        //第一种遍历方式
        Iterator iterator=list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //第二种遍历方式
        for(Object o:list){
            System.out.println(o);
        }
    }
}

 

12.3 List接口

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

public class Test {
    public static void main(String[] args) {
        List list=new ArrayList();
        List list1=new ArrayList();
        list.add(10);
        list.add("byx");
        list.add(true);
        list.add(list1);

        //第一种遍历方式
        Iterator iterator=list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //第二种遍历方式
        for(Object o:list){
            System.out.println(o);
        }

        list.remove(1);
        System.out.println(list.contains("byx"));
        list.addAll(new ArrayList(4));

        System.out.println(list.subList(0,2));
    }
}

 

注意：sublist这个方法少用 因为对它返回的子集合或者原集合操作 两个集合会相互影响 还容易出异常

List三种遍历方式：

12.4 ArrayList 底层及源码

public class Test {
    public static void main(String[] args) {
        ArrayList list=new ArrayList(8);
        for(int i=1;i<=10;i++){
            list.add(i);
        }
        System.out.println(list.get(9));
    }
}

 

 12.5 Vector底层

public class Test {
    public static void main(String[] args) {
        Vector vector =new Vector(8);
        for(int i=1;i<=10;i++){
            vector.add(i);
        }
        System.out.println(vector.get(9));
    }
}

 

 

 12.6 Linkedlist底层

public class Test {
    public static void main(String[] args) {
        LinkedList linkedList =new LinkedList();
        for(int i=1;i<=10;i++){
            linkedList.add(i);
        }
        System.out.println(linkedList.get(9));
        linkedList.set(0,"byx");
        System.out.println(linkedList);
    }
}

 
12.7 ArrayList LinkedList比较

 12.8 Set接口

 常用方法

public class Test {
    public static void main(String[] args) {
        Set set =new HashSet();
        for(int i=1;i<=10;i++){
            set.add(i);
        }
        System.out.println(set);

        Iterator iterator=set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        for(Object object:set){
            System.out.println(object);
        }
    }
}

 

12.9 HashSet

import java.util.*;

public class Test {
    public static void main(String[] args) {
        HashSet set =new HashSet();
        for(int i=1;i<=10;i++){
            set.add(i);
        }
        set.add(new String("byx"));
        set.add(new String("byx"));//无法添加 因为string同一个对象指向的是常量池中同一个位置
        set.add(new Dog());
        set.add(new Dog());//可以添加 因为Dog是新创建的两个对象 他们的引用不同

        System.out.println(set);

        Iterator iterator=set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        for(Object object:set){
            System.out.println(object);
        }
    }
}

class Dog{
    
}

 

底层

 

扩容分两种情况，第一种情况是在长度大于等于8的链表后面加结点，如果数组大小没到64，则继续扩容，并且将此结点添加到链表尾（单条链表没有数量限制，别认为hashset一条链表限制8个元素）；第二种情况是看临界值扩容，当我们向 hashset 增加一个元素，-> Node -> 加入 table , 就算是增加了一个 size++，当到了临界值12，再添加一个元素到13的时候，就会触发扩容机制，而不是看table数组有没有用了12个不同的索引。

 12.10 LinkedHashset

 

 12.11Map接口

 

public class Test {
    public static void main(String[] args) {
        HashMap map =new HashMap();
        for(int i=1;i<=10;i++){
            map.put(i,i+1);
        }
        map.put(1,new String("byx"));//key相同就替换value


        System.out.println(map);
        
    }
}

 

 

public class Test {
    public static void main(String[] args) {
        HashMap map =new HashMap();
        for(int i=1;i<=10;i++){
            map.put(i,i+1);
        }
        map.put(1,new String("byx"));//key相同就替换value

        System.out.println(map);

        Set set=map.entrySet();
        System.out.println(set.getClass());
        for(Object obj:set){
            Map.Entry entry=(Map.Entry)obj;//向下转型 利用Map.Entry的方法
            System.out.print(entry.getKey()+" ");
            System.out.println();
            System.out.print(entry.getValue()+" ");
        }

        Set set1=map.keySet();
        System.out.println(set1.getClass());
        Collection values=map.values();
        System.out.println(values.getClass());
    }
}

 

 

常用方法

 

 遍历方法 3种

public class Test {
    public static void main(String[] args) {
        HashMap map =new HashMap();
        for(int i=1;i<=10;i++){
            map.put(i,i+1);
        }

        Set set=map.keySet();//第一种遍历方式 增强for循环
        for(Object obj:set){
            System.out.println("key: "+obj+" value:"+map.get(obj));
        }

        Iterator iterator=set.iterator();//第二种遍历方式 迭代器
        while (iterator.hasNext()){
            Object key=iterator.next();
            System.out.println("key: "+key+" value:"+map.get(key));
        }

        //上一类方法是先取出key 再去查找map中对应的value 下面介绍第二类 通过EntrySet获取键值对
        Set entrySet=map.entrySet();
        for(Object entry:entrySet){
            Map.Entry m=(Map.Entry) entry;
            System.out.println("key: "+m.getKey()+" value:"+m.getValue());
        }
        Iterator iterator1=entrySet.iterator();//第二种遍历方式 迭代器
        while (iterator1.hasNext()){
            Object entry=iterator1.next();
            Map.Entry m=(Map.Entry) entry;
            System.out.println("key: "+m.getKey()+" value:"+m.getValue());
        }


    }
}

 

 

12.12 HashMap

 

 

 12.13 HashTable

 

 
12.14 Properties

12.15 开发时如何选择合适 的集合实现类

LinkedHashSet的底层是LinkedHashMap，LinkedHashMap的底层是HashMap。 

12.16 Collections 工具类

 

import java.util.*;
@SuppressWarnings({"all"})
public class Collections_ {
    public static void main(String[] args) {
        //创建ArrayList 集合，用于测试.
        List list = new ArrayList();
        list.add("tom");
        list.add("smith");
        list.add("king");
        list.add("milan");
        list.add("tom");

//        reverse(List)：反转 List 中元素的顺序
        Collections.reverse(list);
        System.out.println("list=" + list);
//        shuffle(List)：对 List 集合元素进行随机排序
//        for (int i = 0; i < 5; i++) {
//            Collections.shuffle(list);
//            System.out.println("list=" + list);
//        }

//        sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        Collections.sort(list);
        System.out.println("自然排序后");
        System.out.println("list=" + list);
//        sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        //我们希望按照 字符串的长度大小排序
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //可以加入校验代码.
                return ((String) o2).length() - ((String) o1).length();//List允许重复，所以能同时有两个长度相同的
            }
        });
        System.out.println("字符串长度大小排序=" + list);
//        swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
        //比如
        Collections.swap(list, 0, 1);
        System.out.println("交换后的情况");
        System.out.println("list=" + list);

        //Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
        System.out.println("自然顺序最大元素=" + Collections.max(list));
        //Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
        //比如，我们要返回长度最大的元素
        Object maxObject = Collections.max(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });
        System.out.println("长度最大的元素=" + maxObject);

        //Object min(Collection)
        //Object min(Collection，Comparator)
        //上面的两个方法，参考max即可

        //int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
        System.out.println("tom出现的次数=" + Collections.frequency(list, "tom"));

        //void copy(List dest,List src)：将src中的内容复制到dest中
        ArrayList dest = new ArrayList();
        //为了完成一个完整拷贝，我们需要先给dest 赋值，大小和list.size()一样
        for(int i = 0; i < list.size(); i++) {
            dest.add("");
        }
        //注意：size是指元素个数，而length是数组长度，构造器是不会改变size的。不能通过初始化集合来给定大小，因为这并不会改变size，底层是用两个集合的size比较的，size 和 length 不能等同，size 表示 当前集合的元素个数， 随着元素的增加而增加。

        //拷贝
        Collections.copy(dest, list);
        System.out.println("dest=" + dest);

        //boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
        //如果list中，有tom 就替换成 汤姆
        Collections.replaceAll(list, "tom", "汤姆");
        System.out.println("list替换后=" + list);
    }
}

 

 

感谢各位读者观看 希望各位有什么问题多多沟通~ 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值