Day52.Java集合复习 -Java常用类、集合#、IO

最新推荐文章于 2023-04-28 10:23:09 发布

阿昌喜欢吃黄桃

最新推荐文章于 2023-04-28 10:23:09 发布

阅读量229

点赞数 1

分类专栏： JavaSE 文章标签：链表 java 数据结构 hashmap

本文链接：https://blog.csdn.net/qq_43284469/article/details/108697313

版权

JavaSE 专栏收录该内容

181 篇文章 29 订阅

订阅专栏

Java集合

数组与集合

1.集合与数组的存储数据概述:

集合、数组都是对多个数据进行存储操作的结构，简称:Java容器。*
说明: 此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt，.jpg，.avi，数据库中)

2.数组存储的特点:

/*
	> 一旦初始化以后，其长度就确定了。
	> 数组需要指明数组元素的类型，其一旦定义好，其元素的类型就确定了。只能操作指定类型的数据了。
    	比如:String[] arr;int[] arr1;Object[] arr2;
*/

3.数组存储的弊端:

/*
	> 一旦初始化以后，其长度就不可修改。
	> 数组中提供的方法有限，对于添加、删除、插入数据等操作，非常不便，同时效率也不高。
	> 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。
	> 数组存储数据特点:有序、可重复。 对于无序、不可重复的需求，数组不能满足。
*/

4.集合存储的优点：

解决数组存储数据方面的弊端。

Collection接口

1.单列集合框架结构:

/*
|----Collection接口: 单列集合，用来存储一个一个的对象
      |----List接口: 存储有序的、可重复的数据 ---> "动态"数组
          |----ArrayList、LinkedList、Vector

      |----Set接口: 存储无序的、不可重复的数据 ---> 高中讲的"集合"
          |----HashSet、LinkedHashSet、TreeSet
*/

对应图示:
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eWMVWmp8-1600601907214)(C:\Users\PePe\AppData\Roaming\Typora\typora-user-images\image-20200916205553003.png)]$

2.Collection接口常用方法:

add(Object obj)、addAll(Collection coll)、size()、isEmpty()、clear()；

contains(Object obj),containsAll(Collection coll)、remove(Object obj)、removeAll(Collection coll)、retainAll(Collection coll)、equals(Object obj)、hashCode()、toArray()、iterator()

3.Collection集合与数组间转换

//toArray():
//集合 --->数组
Object[] arr = coll.toArray(T...t);
for (int i = 0; i < arr.length; i++) {//遍历元素
    System.out.println(arr[i]); //1458
                                //123
                                //Person{name='PePe', age=21}
                                //Tom
}
//拓展:
//Array类的静态方法asList()
//数组 --->集合
List<String> stringList = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(stringList);//[AA, BB, CC]

List<int[]> arr1 = Arrays.asList(new int[]{123, 234});//默认的将它认为是一个元素
System.out.println(arr1.size());//1

List arr2 = Arrays.asList(new Integer[]{123, 234});
System.out.println(arr2.size());//2

4.使用Collection集合存储对象，要求对象所属的类满足:

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()。

5.本章的要求:

层次一:

选择合适的集合类去实现数据的保存，调用其内部相关的方法。

层次二:

不同的集合类底层的数据结构为何?如何实现数据的操作:增删改查等。

Iterator接口与foreach循环

1.遍历Collection的两种方式:

①使用迭代器Iterator

②foreach循环(或增强for循环)

2.java.util包下定义的迭代器接口:Iterator

说明:

Iterator对象成为的带起(设计模式的一种)，主要用于 遍历Collection 集合中的元素。
GOF给迭代器模式的定义为: 提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生

作用: 遍历集合Collection元素

如何获取实例: coll.iterator()返回一个迭代器的实例

遍历的代码实现:

   Iterator iterator = coll.iterator();
   //hasNext(): 判断是否还有下一个元素
    while (iterator.hasNext()){
        //next(): ①指针下移 ②将下移以后集合位置上的元素返回
        System.out.println(iterator.next());

图示说明:

在这里插入图片描述

remove()的使用:

//测试Iterator中的remove()方法
//如果还未调用next() 或 在一次调用next()方法之前调用了多次remove方法---->就会报错IllegalStateException
//Iterator迭代器内部定义了remove()方法，可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()。
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(1458);
        coll.add(123);
        coll.add(new Person("PePe",21));
        coll.add(new String("Tom"));

        //删除集合中"Tom"数据
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){

//          iterator.remove();//报错IllegalStateException
            //不要在没next()之前调用remove()方法

            Object obj = iterator.next();
            if ("Tom".equals(obj)){
                iterator.remove();

//              iterator.remove();//报错IllegalStateException
                //在下一次next()之前不能调用两次remove()
            }
        }

        //遍历集合
        Iterator iterator1 = coll.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
                                                /*
                                                1458
                                                123
                                                Person{name='PePe', age=21}
                                                 */
        }
    }

3.jdk5.0新特性–增强for循环:(foreach循环)

遍历集合举例:

@Test
public void test1(){
    Collection coll = new ArrayList();
    coll.add(1458);
    coll.add(123);
    coll.add(new Person("PePe",21));
    coll.add(new String("Tom"));

    //for(集合中元素的类型 局部变量 : 集合对象)
    for(Object obj:coll){
        System.out.println(obj);//1458
                                //123
                                //Person{name='PePe', age=21}
                                //Tom
    }
}

说明:

内部底层仍然还是调用了迭代器iterator.

遍历数组举例:

@Test
public void test2(){
    int[] arr = new int[]{1,2,348,5,8,94};

    //for(数组中元素的类型 局部变量 : 数组对象)
    for (int i: arr ){
        System.out.println(i);
    }
}

Collection子接口: List接口

1. 存储的数据特点:

存储有序的、可重复的数据

2. 常用方法:(记住)

总结:常用方法
增:add(Object obj)
删:remove(int index) / remove(Object obj)
改:set(int index,Object ele)
查:get(int index)
插:add(int index,Object ele)
长度:size()
遍历: 1.Iterator迭代器方式
     2.增强for循环 foreach
     3.普通的循环

3. 常用实现类:

|----Collection接口: 单列集合，用来存储一个一个的对象
     |----List接口: 存储有序的、可重复的数据 ---> "动态"数组,替换原有的数组
         |----ArrayList: JDK 1.2,作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
         |----LinkedList: JDK 1.2,作为List接口的主要实现类；线程不安全的，效率高；底层使用双向链表存储;对于频繁的插入、删除操作，使用此类比ArrayList高;
         |----Vector: JKD 1.0,作为List接口的古老实现类；线程安全的，效率低;底层使用Object[] elementData存储

4. 源码分析(难点):

ArrayList源码分析:

//jkd 7 情况下:

ArraysList list = new ArrayList(); //底层创建了长度是10的Object[]数组elementDate
list.add(123); // elementDate[0] = new Integer(123);
...
list.add(11);// 如果此次的添加导致底层elemengtDate数组容量不够，则扩容。
默认情况下，扩容为原来容量的1.5倍 (oldCapacity+(oldCapacity >> 1))，同时需要将原有数组中的数据复制到新的数组中。

结论:建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity)

//jkd 8 的变化:
    
ArraysList list = new ArrayList(); //底层Object[] elementDate初始化为{}。并没有创建长度为0的数组；

list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementDate[0]
...
后续添加操作和扩容操作与jdk 7 无异。

小结:
    jdk 7 中ArrayList的对象的创建类似与单例的饿汉式;
    jdk 8 中的ArrayList的对象创建类似与单例的懒汉式，延迟了数组的创建，节省内存。

LinkedList的源码分析:



LinkedList list = new LinkedList(); 内部声明了Node类型的frist和last属性，默认值为null
list.add();//将123封装到Node中，创建了Node对象。

其中，Node定义为: 体现了LinkedList的双向链表的说法
    private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

Vector的源码分析:

    jdk 7 和jdk 8 中通过Vector()构造器创建对象时，底层都创建了长度为10的数组
    在扩容方面，默认扩容为原来的数组长度的2倍

5. 存储的元素的要求:

添加的对象,所在的类要求重写equals()方法

面试题

面试题: ArrayList、LinkedList、Vector的三者异同？
同: 三个类都实现了List接口，存储数据的特点相同： 存储有序的、可重复的数据
异:   |----ArrayList: JDK 1.2,作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
      |----LinkedList: JDK 1.2,作为List接口的主要实现类；线程不安全的，效率高；
                        底层使用双向链表存储;对于频繁的插入、删除操作，使用此类比ArrayList高;
      |----Vector: JKD 1.0,作为List接口的古老实现类；线程安全的，效率低;底层使用Object[] elementData存储

Collection子接口: Set接口

1. 存储的数据特点:

无序的、不可重复的元素

具体的:

以HashSet为例说明:
1. 无序性: 不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值觉得的。
2. 不可重复性: 保证添加的元素按照equals()方法判断时,不能返回true.即:相同的元素只能添加一个

2. 元素添加过程:(以HashSet为例子)

以HashSet为例:
    我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
    此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置),判断数组
    此位置上是否已经有元素:
        如果此位置上没有元素，则元素a添加成功。 --->情况1
        如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的哈希值:
            如果哈希值不相同，则元素a添加成功。 --->情况2
            如果哈希值相同,进而需要调用元素a所在类的equals()方法:
                equals()返回true,元素a与对比元素一样，元素a添加失败
                equals()返回false,元素a与现有的元素不一样，则元素a添加成功 --->情况3
    说明：
    对于添加成功的情况2和情况3而言: 元素a与已经存在指定索引位置上的数据以链表的方式存储。
    jdk 7 :元素a 放到数组中，并指向原来的元素。
    jdk 8 :原来的元素放在数组中，并指向元素a
    ↑总结:7上8下

    HashSet底层: 数组 + 链表 的结构。(jdk 7)

3. 常用方法

Set接口中没有额外定义新的方法,使用的都是Collection中声明过的方法。

4. 常用实现类

|----Collection接口: 单列集合，用来存储一个一个的对象
     |----Set接口: 存储无序的、不可重复的数据 ---> 高中讲的"集合"
           |----HashSet: 作为Set接口的主要实现类;线程不安全的;可以存储null值
               |----LinkedHashSet: 作为HashSet的子类,遍历其内部数据时,可以按照添加的顺序去遍历
                                   对于比较频繁的遍历操作,LinkedHashSet效率要 高于HashSet
                   				   每一个数据还维护了两个引用，来记录此数据前一个数据和后一个数据。
               |----TreeSet: 可以按照添元素的指定属性，进行排序

5. 存储对象所在类的要求

HashSet/LinkedHashSet:

要求：向Set(主要: HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode() 和 equals()
重写的的hashCode() 和 equals()方法尽可能保持一致性:相等的对象必须具有相等的散列码
重写两方法小技巧:对象中用作equals()方法比较的Field,都应该用来计算hashCode值

TreeSet:

自然排序中，比较两个对象是否相同的标准为:compareTo()返回0,不在是equals()方法

定制排序中，比较两个对象是否相同的标准为:compare()返回0,不在是equals()方法

6.TreeSet的使用

使用说明:

向TreeSet中添加的数据,要求是由相同类的对象
两种排序方式: 自然排序(实现Comparable接口) 和定制排序(Comparator)

常用的排序方式:

//方式一:
//自然排序:在排序的类中重写CompareTo()方法

@Test
    public void test1() {
        TreeSet treeSet = new TreeSet();

        //失败: 不能添加不同类的对象:
//        treeSet.add(156);
//        treeSet.add(167);
//        treeSet.add("aa");
//        treeSet.add(new User("Jeyy",12));
        //ClassCastException

        //举例一:
//        treeSet.add(34);
//        treeSet.add(912);
//        treeSet.add(-41);
//        treeSet.add(2);

        //举例二:
//          treeSet.add("obi");
//          treeSet.add("GG");
//          treeSet.add("JJ");
//          treeSet.add("MM");

        treeSet.add(new User("Jeyy", 12));
        treeSet.add(new User("Tom", 23));
        treeSet.add(new User("Tom", 56));
        treeSet.add(new User("Mike", 2));
        treeSet.add(new User("Bob", 42));

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

//方式二:
//定制排序

@Test
    public void test2() {
        Comparator com = new Comparator() {
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User && o2 instanceof User) {
                    User u1 = (User) o1;
                    User u2 = (User) o2;
                    return Integer.compare(u1.getAge(), u2.getAge());
                } else {
                    throw new RuntimeException("输入有误");
                }
            }
        };

//在TreeSet中写明排序com
        TreeSet set = new TreeSet(com);
        set.add(new User("Jeyy", 12));
        set.add(new User("Tim", 23));
        set.add(new User("Tom", 56));
        set.add(new User("Mike", 2));
        set.add(new User("Bob", 42));
        set.add(new User("Nike", 42));

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

双列集合框架: Map

1.常用实现类结构

|----Map: 双列数据,用于存储key-value对 的数据   ---类似于高中的函数:y=f(x)
     |----HashMap: jdk1.2出现;作为Map的主要实现类;线程不安全,效率高;可存储null的key和value;
         |----LinkedHashMap: jdk1.4出现;保证在遍历map元素时,可以按照添加的顺序实现遍历;是HashMap的子类
             原因: 在原有的HashMap底层构造基础上,添加了一对引用指针,指向前一个和后一个元素。
                  对于频繁的遍历操作,此类LinkedHashMap执行效率高于HashMap
     |----TreeMap: jdk1.2出现;保证按照添加的key-value对 进行排序,实现排序遍历。此时是考虑对key的自然排序或定制排序。
                   底层使用了红黑树
     |----Hashtable: jdk1.0出现;作为古老的实现类;线程安全,效率低;不能存储null的key和value
         |----properties: 常用来处理配置文件;是Hashtable的子类;他的key和value都是String类型


HashMap的底层: 数组 + 链表 (jdk 7 之前)
              数组 + 链表 + 红黑树 (jdk 8)

[面试题]

1. HashMap的底层实现原理?---(高频)
2. HashMap 和 Hashtable的异同?
3. CurrentHashMap 与 Hashtable的异同?---(暂时不讲)

2.存储结构的理解:

>Map中的key: 
无序的、不可重复的,使用Set存储所有的key --->key所在的类要重写equals()方法和hashCode()方法 (以HashMap为例)
    
>Map中的value: 
无序的、可重复的,使用Collection存储所有的value --->value所在的类要重学equals()方法
    
一个键值对: key-value构成了一个Entry对象。key和value是Entry对象的属性
    
>Map中的entry: 
无序的、不可重复的,使用Set存储所有的entry

图示

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MWt3IaXQ-1601035945876)(C:\Users\PePe\AppData\Roaming\Typora\typora-user-images\image-20200925192245255.png)]$

3.常用方法

>添加: put(Object key,Object value)
>删除: remove(Object key)
>修改: put(Object key,Object value)
>查询：get(Object key)
>长度: size()
>遍历: keySet() / values() / entrySet()

4.内存结构说明:（难点）

HashMap在 jdk 7 中实现原理:

HashMap map = new HashMap();	
	在实例化后，底层创建了长度为16的一维数组,类型为Entry[] table。
	...可能已经执行过多次put...
map.put(key1,value1);
	首先,调用key1所在类的hashCode()方法,计算key1的哈希值,此哈希值经过某种算法计算后,得到Entry[]数组的存放位置
    如果此位置上的数据为空,此时的key1-value1添加成功。 ----情况1
    如果此位置上的数据不为空,(此位置上存在一个或多个数据(以链表形式存在)),比较key1与已经存在的一个或多个数据的哈希值:
        如果key1的哈希值与已经存在的数据的哈希值都不相同,此时key1-value1添加成功。 ----情况2
        如果key1的哈希值与某一个数据(key2-value2)的哈希值的相同,继续比较: 调用key1所在类的equals(key2)方法,进行比较:
            如果equals()返回false:此时key1-value1添加成功。 ----情况3
            如果equals()放回true:使用value1替换value2的值。

补充: 关于情况2和情况3: 此时key1-value1和原来的数据以链表的方式存储。

在不断的添加过程中，会涉及到扩容问题: 默认的扩容方式:当超出threshold临界值(且要存放的位置非空)时,扩容为原来容量的2倍,并将原有的数据复制过来。

HashMap在 jdk 8 中相较与 jdk 7在底层实现方面的不同:

1. new HashMap():底层没有创建一个长度为16的Entry[]
2. jdk 8 底层的数组是: Node[],而非Entry[]
3. 首次调用put()方法时,底层创建长度为16的数组
4. jdk 7 底层结构只有: 数组 + 链表。 jdk 8 底层结构: 数组 + 链表 + 红黑树。
    形成链表时,7上8下(jdk7 是新的元素指向旧的的元素;jdk8 是旧的元素指向新的元素)
    
    当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时,
    此时此索引位置上的所有数据改为使用红黑树存储。

HashMap底层典型属性的属性的说明:

DEFAULT_INITIAL_CAPACITY ： HashMap的默认容量: 16
DEFAULT_LOAD_FACTOR : HashMap的默认加载因子: 0.75
threshold: 扩容的临界值 = 容量 * 加载因子 : 16 * 0.75 => 12
TREEIFY_THRESHOLD： Bucket中链表长度大于该默认值,转化为红黑树 : 8
MIN_TREEIFY_CAPACITY: 桶中的Node被树划时最小的hash表容量: 64

LinkedHashMap的底层实现原理(了解)

LinkedHashMap底层使用的结构与HashMap相同,

因为LinkedHashMap继承与HashMap

区别在于:

LinkedHashMap内部提供了Entry,替换HashMap中的Node

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-huPVUn89-1601035945879)(C:\Users\PePe\AppData\Roaming\Typora\typora-user-images\image-20200925194635900.png)]$

5.TreeMap的使用

向TreeMap中添加key-value,要求key必须是由同一个类创建的对象

因为要按照key进行排序: 自然排序 与 定制排序

6.使用properties读取配置文件

//Properties: 常用来处理配置文件; key和value都是String类型
public static void main(String[] args)  {
    FileInputStream fis = null;
    try {
        Properties pros = new Properties();
        fis = new FileInputStream("jdbc.properties");
        pros.load(fis);//加载流对应的文件

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");

        System.out.println("name ="+name + "，password ="+password);//name =PePe郑彦昌，password =16839886
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fis != null){
        }
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Collections工具类的使用

1.作用:

操作Collection接口与 Map接口的工具类

2.常用方法:

reverse(List): 反转 List 中元素的顺序
shuffle(List): 对 List 集合元素进行随机排序
sort(List): 根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List,Comparator): 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List,int i,int j): 将指定 List 集合中的 i 处元素 和 j 处元素进行交换

Object max(Collection): 根据元素的自然顺序,返回给定集合中的最大元素
Object max(Collection,Comparator): 根据Comparator指定的顺序,返回给定集合中的最大元素
Object min(Collection): 根据元素的自然顺序,返回给定集合中的最小元素
Object min(Collection,Comparator): 根据Comparator指定的顺序,返回给定集合中的最小元素
int frequency(Collection,Object): 返回指定集合中指定元素的出现次数
void copy(List dest,List src): 将src中的内容复制到dest中
boolean replaceAll(List list,Object oldVal,Object newVal): 使用新值替换 List对象 的所有旧值

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dj4iGawV-1601035945881)(C:\Users\PePe\AppData\Roaming\Typora\typora-user-images\image-20200925195422786.png)]$

说明:
ArrayList和HashMap都是线程不安全的,如果程序要求线程安全,我们可以将ArrayList、HashMap转换为线程安全的。

使用synchronizedList(List list) 和synchronizedMap(Map map)

3.面试题:

面试题: Collection 与 Collections的区别？
Collection 是接口
Collections 是操作Collection接口的工具类

阿昌喜欢吃黄桃

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
1
评论
Day52.Java集合复习 -Java常用类、集合#、IO

Java集合数组与集合1.集合与数组的存储数据概述:集合、数组都是对多个数据进行存储操作的结构，简称:Java容器。*说明: 此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt，.jpg，.avi，数据库中)2.数组存储的特点:/* > 一旦初始化以后，其长度就确定了。 > 数组需要指明数组元素的类型，其一旦定义好，其元素的类型就确定了。只能操作指定类型的数据了。比如:String[] arr;int[] arr1;Object[] arr2;*/
复制链接

扫一扫