12.2021二合一 Java基础 16

  • 由于12月20日作业想岔了。。花费太多时间，刚好21日老师还是讲List, Set和Map相关内容，再加上新学的泛型，索性将两天的内容放在一起归纳总结。
  • 要点：1.collection
        list
            ArrayList(常用)
                不安全，但是查询速度快
                add 添加
                get 获取
                remove 删除
            LinkedList
                安全，但是速度没有ArrayList快
                getFirst
                getLast
                addFirst
                addLast
            Vector
                已被ArrayList替代
            Stack
                push 添加
                pop 结合了get和remove
        queue 队列
        set
            HashSet
                元素唯一，不可重复
            TreeSet（如果涉及到排序，就需要用到）
                元素唯一，不可重复，可排序
    2.map
        键值对，key和value
        key唯一
        HashMap(常用)
            添加慢，查询快
            put
            remove
            clear
            size
        LinkedHashMap
            添加快，查询慢
        HashTable
            线程安全，速度慢，不允许存放null键，null值，已被HashMap替代。
        ConcurrentHashMap
            用法同hashMap
        TreeMap（如果涉及到排序，就需要用到）
            可排序
        Properties（常用，但是是框架帮我写好了）
            读取文件
  • 集合类
  • 数组和集合的异同点

数组和集合类都是容器。

数组长度是固定的；集合长度是可变的。

数组中可以存储基本数据类型和引用数据类型，集合只能存储对象。

数组中存储数据类型是单一的，集合中可以存储任意类型的对象。

  • Collection接口

Collection接口有三个子接口

List（列表） ，Set（集）、Queue(队列)

List：元素存取是有序的，可存放重复元素。元素都有下标。

Set：元素存取是无序的，不可以存放重复元素。元素没有下标，元素不可以重复。

Queue：队列，实现了先进先出。

collection接口中的方法：

boolean add(E e)

确保此collection包含指定的元素

boolean addAll(Collection<?extendsE> c)

将指定collection中的所有元素都添加到此collection中

boolean remove(Object o)

从该集合中删除指定元素

boolean removeAll(Collection<?> c)

删除指定集合中包含的所有此集合的元素

boolean isEmpty()

如果此collection不包含元素，则返回true

boolean contains(Object o)

如果此collection包含指定的元素，则返回true

boolean containsAll(Collection<?> c)

如果此collection包含指定collection中的所有元素，则返回true

int size()

返回此collection中的元素数

Object[] toArray()

返回一个包含此集合中所有元素的数组

几种常见的遍历方法

         //遍历(增强)（优先级2）（增强型for循环 一定要有泛型）
        for (String str : list) {
            System.out.println(str);
        }

        // 遍历(iterator)
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next().toString());
        }

        // forEach遍历（优先级1）
        list.forEach(listFor -> {
            System.out.println(listFor);
        });

        Integer listI = 0;
        while (listI < list.size()) {
            System.out.println(list.get(listI));
            listI++;
        }
        
        // for遍历
        for (int i2 = 0; i2 < list.size(); i2++) {（优先级3，效率较低）
            System.out.println("for:"+list.get(i2));
        }

  • List接口实现类

ArrayList：线程不安全，底层使用数组实现，可变长度，查询速度快，增删慢（有序插入，可重复）

LinkedList：链表结构，底层使用链表实现，可变长度，增删速度快，查询慢

Vector：底层使用数组实现，线程安全，但速度慢，已被ArrayList替代

Stack: 先进后出, 底层调用Vector类中方法，数组实现

  • 在Collection基础上扩展了一些方法

方法

功能

boolean add(E element)

在列表的末尾顺序添加元素，起始索引位置从0开始

void add(int index, E element)

在列表的指定位置插入指定元素

E set(int index, E element)

用指定的元素，替换此列表中指定位置的元素。

E get(int index)

返回列表中指定位置的元素

E remove(int index)

移除列表中指定位置的元素

List<E> subList(int fromIndex, int toIndex)

返回列表中指定的fromIndex（包括）和toIndex（不包括）之间的部分视图

int size()

返回列表中的元素个数

boolean contains(Object o)

判断列表中是否存在指定元素

构造方法：

构造方法

功能

public ArrayList(){}

构造一个空列表。

public ArrayList(int initialCapacity) {}

构造具有指定初始容量的空列表。

ArrayList(Collection<? extends E> c)

构造一个包含指定集合元素的列表，按照它们由集合的迭代器返回的顺序。

ArrayList存储数据当快溢出时，就会进行扩容操作 ArrayList的默认扩容扩展后数组大小为：原数组长度+(原数组长度>>1)

  • LinkedList类

方法

功能

public void addFirst(E e)

将指定元素插入此列表的开头

public void addLast(E e)

将指定元素添加到此列表的结尾

public E getFirst()

返回此列表的第一个元素

public E getLast()

返回此列表的最后一个元素

public E removeFirst()

移除并返回此列表的第一个元素

public E removeLast()

移除并返回此列表的最后一个元素

Vector向量

Vector在进行默认规则扩容时，新数组的长度=原始数组长度*2，也可以指定扩容长度；

创建对象的时候初始化长度为10。

方法

功能

void add(int index, E element)

在列表的指定位置插入指定元素

void add(E element)

在集合末尾添加元素

E get(int index)

返回列表中指定位置的元素

E remove(int index)

移除列表中指定位置的元素

public Enumeration<E> elements()

返回集合中的所有元素，封装到Enumeration对象中
  • Interface Enumeration<E>是接口

boolean hasMoreElements()

测试此枚举是否包含更多元素。

E nextElement()

如果此枚举对象至少有一个要提供的元素，则返回此枚举的下一个元素

ArrayList与Vector的区别？

相同点：ArrayList与Vector的底层都是由数组实现的。

不同点：

1、ArrayList不同步，线程相对不安全，效率相对高；Vector同步的，线程相对安全，效率相对较低。                        

2、ArrayList是JDK1.2出现的。Vector是jdk1.0的时候出现的。

3、扩容方式

     ArrayList扩容方式：原来数组长度1.5倍

     Vector扩容方式： 默认是原来数组长度的2倍

4、实现方法不同

 

Stack

特点：先进后出

底层：调用Vector类中方法，数组实现

 

  • Set接口中常用的子类：

HashSet：底层调用HashMap中的方法，集合元素唯一，不保证迭代顺序，线程不安全(不同步)，存取速度快。

TreeSet： TreeSet中元素不重复，并能按照指定顺序排列。存储的对象必须实现Comparable接口。线程不安全(不同步)。

LinkedHashSet: 哈希表和链表实现了Set接口，元素唯一，保证迭代顺序。

 

HashSet

常用方法：

  • boolean add(E e) 将指定的元素添加到此集合（如果尚未存在）。
  • void clear() 从此集合中删除所有元素。
  • boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
  • boolean remove(Object o) 如果存在，则从该集合中删除指定的元素。
  • int size() 返回此集合中的元素个数。

特点：

  • HashSet：无序不重复，无索引
  • 默认不重复的是虚地址，要想内容不重复，就重写hashcode和equals方法。
  • 底层是HashMap实现，HashMap底层是由数组+链表+红黑树实现
  • HashSet堪称查询速度最快的集合，因为其内部是以HashCode来实现的。它内部元素的顺序是由哈希码来决定的，所以它不保证set的迭代顺序；特别是它不保证该顺序恒久不变

 

TreeSet

要点：可排序，排序时实体类要实现 Comparable接口

 

Map

Map存储的是键值对，必须保证键是唯一的。而且它没有继承Collection。

 

Map集合常用类

HashMap：线程不安全，速度快，允许存放null键，null值。

LinkedHashMap继承自HashMap，它主要是用链表实现来扩展HashMap类

Hashtable：线程安全，速度慢，不允许存放null键，null值，已被HashMap替代。

ConcurrentHashMap：线程安全并且高效的HashMap

TreeMap：对键进行排序，排序原理与TreeSet相同。

 

Map接口提供的针对键值对的操作方法：

方法

功能

V put(K key, V value)

将指定的值与此映射中的指定键关联

void clear()

从此映射中移除所有映射关系

V remove(Object key)

如果存在一个键的映射关系，则将其从此映射中移除

boolean  containsKey(Object key)

如果此映射包含指定键的映射关系，则返回 true

boolean containsValue(Object value)

如果此映射将一个或多个键映射到指定值，则返回 true

boolean isEmpty()

如果此映射未包含键-值映射关系，则返回 true

V get(Object key)

返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null

Set<K> keySet()

返回此映射中包含的键的Set视图

int size()

返回此映射中的键-值映射关系数

 

HashMap

特点：

1.底层实现1.7之前:数组+链表 1.8以后：数组+链表+红黑树

2.key不允许重复，如果key的值相同，后添加的数据会覆盖之前的数据

3.HashMap是非线程安全的

常用方法：

1.Object put(Object key, Object val) 以“键-值对”的方式进行存储

2.Object get (Object key) 根据键返回相关联的值，如果不存在指定的键，返回null

3.Object remove (Object key) 删除由指定的键映射的“键-值对”

4.int size() 返回元素个数

5.Set keySet () 返回键的集合

6.Collection values () 返回值的集合

7.boolean containsKey (Object key)   如果存在由指定的键映射的“键-值对”，返回true

 

LinkedHashMap

LinkedHashMap继承自HashMap，它主要是用链表实现来扩展HashMap类

HashMap中条目是没有顺序的

LinkedHashMap中元素按照它们插入的顺序排序

LinkedHashMap里的方法和HashMap没有什么不同

 

Hashtable

HashMap和HashMap的区别在于：

     Hashtable是线程安全的，而HashMap是非线程安全的。

     Hashtable不允许空的键值对，而HashMap可以。

     Hashtable与HashMap都实现Map接口，但二个类的继承的父类不是同一个。

方法同HashMap

 

ConcurrentHashMap

线程安全并且高效。

方法同HashMap

 

TreeMap

可以对Map集合中的元素进行排序。

键可以使用Comparable或Comparator接口, 重写compareTo方法来排序，和treeset很像。

自定义的类必须实现接口和重写方法，否则抛异常。

自定义对象（本身没有比较功能的素）进行排序(要进行比较那就让元素具有比较功能，那就要实现Comparable这个接口里compareTo的方法)。

 

Properites类（继承于 Hashtable，由此间接地实现了Map接口）

在实际应用中，常使用Properties类对属性文件进行处理 eg:数据库账户名和密码

Properites类的键值对都是字符串。

方法

功能

public Object setProperty(String key,String value)

key - 要放入此属性列表的关键字  value - 对应的值为 key

public String getProperty(String key)

返回属性列表中具有指定键值的值

public void load(InputStream inStream)

输入字节流读取属性列表（键和元素对）。

public Set<String> stringPropertyNames()

返回此属性列表中的一组键

要点提及：

1.arrayList(重要)
    add
    remove 
    size 
    
遍历：
    List<String> list = new ArrayList<>();
    1.foreach遍历
        list.forEach(i->{
        
        })
        
    2.增强遍历
        for(数据类型 对象:集合){
        
        }
        for(String str: list){
        
        }    
    3.for循环
        for(int i=0;i<list.size();i++){
            
        }

2.LinkedList
    和arrayList的区别
    多了 addFirst,addLast,getLast,getFirst
    
3.vector 
    用法和list差不多
    
4.stack    
    先进后出
    用的是 push、pop
    pop调用一次，元素就会被删除
    
5.set 不可重复
    hashSet 无排序
    treeSet 排序，要实现 Comparable
6.hashMap（重要）
    键值对（key，value）
    键是唯一
    put
    remove
    get
    size
7.linkHashMap
    记一下用法
8.HashTable
    记一下用法
9.treeMap
    相比其他map，可以排序
    记一下用法
10.properties    
    后面的框架会自动帮我去读取配置文件

主要用到的还是ArrayList和HashMap。

  • 泛型
  • 要点：

1.构造函数
    在创建对象的时候自动执行
    
2.泛型
    可以是任意类型，为什么会有泛型的出现？为了代替Object。
    泛型类：
        Class 类名<T>{
            
        }
        
        类名<String> 对象 = new  类名();
         
    泛型方法：
        public static<T> void print(T t);    
        public <T> void print(T t);
        
        public static<T> void print(T[] ts){
            for(T t:ts){
            
            }
        };    
        public <T> void print(T[] ts);
        
    泛型接口：
        public inteface 接口名<T>{
        
        }

此外，老师还提到：泛型多用于表的增删改查，泛型类与泛型接口用的较多。

未完，代码未贴，先回家

posted on 2021-12-20 23:08  heyiyang1312  阅读(3)  评论(0)    收藏  举报

导航