Java集合这样子学习

最新推荐文章于 2024-04-11 19:11:04 发布

blalbal

最新推荐文章于 2024-04-11 19:11:04 发布

阅读量216

点赞数 1

分类专栏： Java 集合文章标签：学习

本文链接：https://blog.csdn.net/qq_54230971/article/details/126449309

版权

Java 同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

集合

1 篇文章 0 订阅

订阅专栏

耗时五天学完集合的大致内容，韩顺平老师讲的特别透彻

大家有兴趣可以观看韩老师讲课，特别细节！！！

集合首先需要大家记住下面这张图

一、首先是Collection接口

1.实现了Collection接口的子类主要有以下特点：

public interface Collection<E> extends Iterable<E>

1)collection实现子类可以存放多个元素，每个元素可以是Object

2)有些Collection的实现类,可以存放重复的元素，有些不可以

3)有些Collection的实现类，有些是有序的(List)，有些不是有序(Set)

4) Collection接口没有直接的实现子类，是通过它的子接口Set和 List来实现的

2.Collection接口的常用方法

1) add:添加单个元素

2) remove:删除指定元素

3) contains:查找元素是否存在

4) size:获取元素个数

5) isEmpty:判断是否为空

6) clear:清空

7)addAll:添加多个元素

8) containsAll:查找多个元素是否都存在

9) removeAll:删除多个元素

3.Collection接口遍历元素方式1-使用Iterator(迭代器) 2-使用增强for循环

1) Iterator对象称为迭代器,主要用于遍历Collection 集合中的元素。

2)所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器。

3) Iterator仅用于遍历集合,Iterator本身并不存放对象。

Collection col = new ArrayList();
col.add(new Book("三国演义","罗贯中",10.1));
col.add(new Book("小李飞刀","古龙",5.1));
col.add(new Book("红楼梦","曹雪芹",34.3));
System.out.println("col:" + col);
Iterator it = col.iterator();//获取迭代器
while (it.hasNext()) {
    Object next =  it.next();
    System.out.println(next);
}

//增强for
it = col.iterator();
for(Object book : col){
    System.out.println(book);

二、List接口(主要实现类有ArrayList、LinkedList、Vector）

1.特点

1）List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复。

2）List集合中的每个元素都有其对应的顺序索引，即支持索引。

3) List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据

序号存取容器中的元素。

List list = new ArrayList();
list.add("tom");
list.add("jack");
list.add("mary");
list.add("mary");//可重复添加
list.add("smith2");
list.add("kristina");
System.out.println(list);

2.方法

1.void add(int index,Object ele):在index位置插入ele元素

2.boolean addAll(int index,Collection eles): 从index位置开始将eles中的所有元素添加进来

3.0bject get(int index):获取指定index位置的元素

4.int indexOf(Object obj):返回obj在集合中首次出现的位置

5.int lastIndexOf(0bject obj):返回obj在当前集合中末次出现的位置

6.0bject remove(int index):移除指定index位置的元素，并返回此元素

7.0bject set(int index,0bject ele):设置指定index位置的元素为ele ，相当于是替换

8.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

3.List集合遍历方式

//1）方式一：使用iterator
lterator iter = col.iterator();
while(iter.hasNext){
Object o = iter.next();
}

//2)方式二:使用增强for
for(Object o:col){
}

//3）方式三：使用普通for
for(int i=o;i<list.size0;i++){
object object = list.get(i);
System.out.println(object);
}

4.List接口其实现类

i.ArrayList:

1)ArrayList中维护了一个Object类型的数组elementData. [debug 看源码]transient Object[l elementData;

2)当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。

3)如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍。

ii.vectot:

1)Vector底层也是一个对象数组,protected Object[] elementData;

2)Vector是线程同步的，即线程安全, Vector类的操作方法带有synchronized

public synchronized E get(int index){

if (index >= elementCount)

throw new ArraylndexOutOfBoundsException(index);
return elementData(index);

}

3)在开发中,需要线程同步安全时,考虑使用Vector

iii.LinkedList

1)LinkedList实现了双向链表和双端队列特点

2)可以添加任意元素(元素可以重复),包括null

3)线程不安全,没有实现同步

4)双向链表适合增删，如增删操作使用的多的案例使用LinkedList

iv：集合的选择

如何选择ArrayList和LinkedList:

1)如果我们改查的操作多，选择ArrayList

2)如果我们增删的操作多，选择LinkedList

3)一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList

4)在一个项目中，根据业务灵活选择，也可能这样，一个模块使用的是ArrayList,另

外一个模块是LinkedList.

三、Set接口（主要实现类有HashSet、LinkedHashSet和TreeSet）

1.特点

1)无序（添加和取出的顺序不一致),没有索引

2)不允许重复元素，所以最多包含一个null

2.常用方法

因为是Collection接口的子接口，因此常用方法和Collection接口一样

3.遍历方式

1）可以使用迭代器

2）可以使用增强for

3）不能使用索引的方式来获取！

4.Set接口其实现类

i.HashSet

1) HashSet实际上是HashMap，看下源码.

//HashSet的构造方法
public Hashset() {
map = new HashMap<>();
}

2)可以存放null值，但是只能有一个null

3) HashSet不保证元素是有序的,取决于hash后,再确定索引的结果

4)不能有重复元素/对象.在前面Set 接口使用已经讲过

5）底层机制:

HashSet的底层是HashMap，HashMap的底层是数组+（单向）链表+加红黑树

6)HashSet在添加元素时底层如何实现（hash()+equals()）

1.添加一个元素时，先得到hash值-会转成->索引值

2.找到存储数据表table，看这个索引

3.如果没有,，直接加入

4.如果有,调用equals 比较，如果相同，就放弃添加,如果不相同,则添加到最后

5.在Java8中,如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MINTREEIFY CAPACITY(默认64)就会进行树化(红黑树)

ii.LinkedHashSet（为HashSet的子类）

1)LinkedHashSet是 HashSet的子类

2)LinkedHashSet底层是一个 LinkedHashMap，底层维护了一个数组+双向链表

3) LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的（取出顺序和添加顺序一致）。

4)LinkedHashSet不允许添重复元素

iii.TreeSet

可以通过有参构造器实现集合的排序

public class TreeSet_ {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
                //return ((String)o1).compareTo((String) o2);
            }
        });
        treeSet.add("b");
        treeSet.add("e");
        treeSet.add("q");
        treeSet.add("a");
        treeSet.add("c");
        System.out.println(treeSet);

    }
}

四、Map接口（Key-Value 键值对）

1.Map接口实现类的特点

1) Map与Collection并列存在（意思是毫不相干)。用于保存具有映射关系的数据:Key-Value

2) Map 中的 key和 value可以是任何引用类型的数据，会封装到HashMap$Node对象中

3) Map 中的key 不允许重复，原因和HashSet一样，前面分析过源码.

4) Map 中的value可以重复

6)常用String类作为Map的key

7) key 和 value之间存在单向一对一关系，即通过指定的key 总能找到对应的value

8) Map存放数据的key-value示意图,一对k-v是放在一个Nod中的，有因为Node实现了Entry 接口,有些书上也说一对k-v就是一个Entry（比较重要看韩老师531集解读）

2.Map接口的常用方法

1) put:添加

2) remove:根据键删除映射关系

3) get:根据键获取值

4) size:获取元素个数

5) isEmpty:判断个数是否为0

6) clear:清除

7) containsKey:查找键是否存在

3.Map的6大遍历方式

public class Map_ {
    public static void main(String[] args) {
        //Map接口实现的特点
        //用于保存映射关系的数据 Key--value
        Map hashmap = new HashMap<>();
        hashmap.put("no1", "李嘉图");
        hashmap.put("no2", "绘梨衣");
        hashmap.put("no3", "陈墨瞳");
        Set set = hashmap.entrySet();
//        for (Object obj : set) {
//            Map.Entry entry = (Map.Entry) obj;
//            System.out.println(entry.getKey() + "-" + entry.getValue());
//        }
//        System.out.println(hashmap.remove("no3"));
//        System.out.println(hashmap.get("no2"));
//        System.out.println(hashmap.size());
//        System.out.println(hashmap.isEmpty());
//        System.out.println(hashmap.containsKey("no1"));
//        hashmap.clear();
        System.out.println("-----第一种方法-----");
        Set Keyset = hashmap.keySet();
        for (Object key : Keyset) {
            System.out.println(key + "-" + hashmap.get(key));
        }
        System.out.println("-----第二种方法-----");
        Iterator it = Keyset.iterator();
        while (it.hasNext()) {
            Object key = it.next();
            System.out.println(key + "-" + hashmap.get(key));
        }
        System.out.println("-----第三种方法-----");
        //第二组 给所有的values取出
        Collection values = hashmap.values();
        //这里可以使用所有的Collections使用的遍历方法
        for (Object value : values) {
            System.out.println(value);
        }
        Iterator it1 = values.iterator();
        while (it1.hasNext()) {
            Object value = it1.next();
            System.out.println(value);
        }
        Set entrySet = hashmap.entrySet();
        for (Object obj : entrySet) {
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }
        System.out.println("-----iterator遍历-----");
        Iterator it2 = entrySet.iterator();
        while (it2.hasNext()) {
            Object next =  it2.next();
            Map.Entry entry = (Map.Entry) next;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }

    }
}

4.Map接口其实现类

i.HashMap

1) HashMap是 Map 接口使用频率最高的实现类。

2) HashMap 是以 key-val 对的方式来存储数据[案例 Entry

3) key不能重复，但是是值可以重复,允许使用null键和null值。

4)如果添加相同的key，则会覆盖原来的key-val ,等同于修改.(key不会替换，val会替换)

5)与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的.

6) HashMap没有实现同步，因此是线程不安全的

ii.HashTable

1)存放的元素是键值对:即K-V

2) hashtable的键和值都不能为null,否则会抛出NullPointerException

3) hashTable使用方法基本上和HashMap一样

4) hashTable是线程安全的

iii.properties

1). Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据。

2).他的使用特点和Hashtable类似

3）. Properties还可以用于从 xoxox.properties文件中，加载数据到Properties类对象,并进行读取和修改

4）．说明:工作后 xx.properties文件通常作为配置文件，这个知识点在IO流举例

iii.TreeMap

可以通过有参构造器实现集合的排序

public class TreeMap_ {
    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).compareTo((String) o2);
            }
        });
        treeMap.put("jack","杰克");
        treeMap.put("tom","汤姆" );
        treeMap.put("kristins","科卡等级");
        treeMap.put("smith","史密斯");
    }
}

五、Collections工具类

1.特点

1) Collections是一个操作 Set、List 和 Map等集合的工具类

2) Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作排序操作:(均为static方法)

2.常用方法

1) reverse(List):反转List 中元素的顺序

2) shuffle(List):对 List 集合元素进行随机排序

3) sort(List):根据元素的自然顺序对指定List 集合元素按升序排序

4) sort(List, Comparator):根据指定的Comparator 产生的顺序对 List 集合元素进行排序

5) swap(List, int,int):将指定list集合中的i处元素和j处元素进行交换

6)Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素

7) Object max(Collection, Comparator):根据Comparator 指定的顺序，返口给定集合中的最大元素

8) Object min(Collection)

9) Object min(Collection, Comparator)

10) int frequency(Collection,Object):返回指定集合中指定元素的出现次数

11) void copy(List dest,List src):将src中的内容复制到dest中

12) boolean replaceAll(List list, Object oldVal, Object newVal):使用新值替换 List 对象的所有旧值

import java.util.*;
public class Conllections_ {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("tom");
        list.add("smith");
        list.add("jack");
        list.add("lucy");
        System.out.println(list);
        System.out.println("====================");
        //从小到大排序
        Collections.reverse(list);
        System.out.println(list);
        System.out.println("====================");
        //随便排序
        Collections.shuffle(list);
        System.out.println(list);
        System.out.println("====================");
        Collections.sort(list, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });
        System.out.println(list);
        //swap 将指定位置的元素进行交换
        System.out.println("=====================");
        Collections.swap(list,0,2);
        System.out.println(list);
        System.out.println("=====================");
        //根据Comparator 指定的顺序返回集合的最大元素
        Object max = Collections.max(list, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });
        System.out.println("长度最大的元素 = " + max);
        System.out.println("=====================");
        System.out.println(Collections.frequency(list,"tom"));
        ArrayList<Object> dest = new ArrayList<>();
        //为了完成一个完整拷贝，玩吗需要献给dest赋值大小和list。size一样
        for (int i = 0; i < list.size(); i++) {
            dest.add("");
        }
        Collections.copy(dest,list);
        System.out.println("dest = " + dest);

    }
}

六、开发中如何选择集合实现类

在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下:

1)先判断存储的类型(一组对象[单列]或一组键值对[双列])

2)一组对象:Collection接口

允许重复:List

增删多:LinkedList[底层维护了一个双向链表]

改查多:ArrayList[底层维护Object类型的可变数组]

不允许重复:Set

无序:HashSet [底层是HashMap，维护了一个哈希表即(数组+链表+红黑树)

排序:TreeSet

插入和取出顺序一致:LinkedHashSet，维护数组+双向链表

3)一组键值对:Map

键无序:HashMap [底层是:哈希表 jdk7:数组+链表，jdk8:数组+链表+红黑树]

键排序:TreeMap

键插入和取出顺序一致:LinkedHashMap

读取文件 Properties

题外话：

学习计算机语言需要持之以恒的努力和付出，需要一点点积累知识，看视频或书籍学习Java，本人还是推荐韩顺平老师的课，他的课讲的特别细节！最重要的是看底层源码解读，从底层机制可以联想到实际开发，提高自己阅读代码的能力！！！还有就是日复一日的练习代码，不懂得地方通过上网查询，一定要弄懂，实践出真理，只有自己试过了才会明白，并且加以记忆，只看一遍视频不会真正理解。学习的过程虽然很艰难，但是只要付出了就会有回报，量变引起质变，加油小白！！！

------------一个假小子