java 基础之集合类

时间：2021-08-20 11:44:03

1、集合概念

集合按照其存储结构可以分为两个大类，即单列集合Collection 和双列集合Map ,这两种集合的特点具体如下：
1）Collection：单列集合类的根接口，用于存储一系列的符合某种规则的元素，他有两个重要的子接口，分别是List 和 Set.
(1)其中list 的特点是元素有序、元素可重复，List 接口主要实现类有ArrayList 和 LinkedList。
（2）set 的特点是元素无序，且元素不可重复。Set 接口实现类是HashSet 和 TreeSet.

2)Map :双列集合类的根接口，用于存储具有键（key）值(Value)对映射关系的元素。每个元素都包含一个键值对。
（1）在使用Map 集合时可以通过指定的Key 找到对应的Value,例如根据学生学号，可以找到对应的学生。
（2）Map 接口的主要实现，类似有HashMap 和TreeMap.

2、Collection接口

Collection是所有单列集合的父接口，因此在Collection 中定义了单列集合（List 和 Set） 通用的一些方法，这些方法可以操作所有的单列集合。
（1） boolean add(Object o) 向集合中添加一个元素。
（2） boolean addAll(Collection c) 将指定Collection 中所有的元素添加到该集合中。
（3）void clear() 删除该集合的所有元素
（4）boolean remove(object o) 删除该集合指定元素
（5）boolean removeAll( Colleation c) 删除该集合所有的元素
（6）boolean isEmpty() 判断该集合是不是空
（7） boolean contains(Object o) 判断该集合是否包含指定的集合中的所有元素
（8）boolean containAll (Collection c) 判断该集合是不是包含指定集合的所有元素
（9）Iterator iterator() 返回在该集合上进行迭代的迭代器（Iterator），用于遍历该集合上所有元素。
（10）int size() 获取该集合元素个数

2.1、List 接口

1）list集合允许出现重复的元素，所有的元素是以一种线性方式来进行存储，在程序中通过索引来访问集合中的指定的元素。
2）list 集合还有一个特点就是元素有序，存入的顺序和取出的顺序一致。

list 作为Collection 集合的子接口，不但继承Collection接口的全部方法，而且还增加了一些元素索引来作为集合的特有方法。

（1）void add(int index,Object element) 将元素element 插入在List集合的index处
（2）boolean addAll(int index,Collection c) 将集合C 包含的所有元素插入到List集合的index处
（3）Object get(int ubdex) 返回集合索引index处的元素
（4）Object set(int index,Object element) 将索引index处元素替换成element 对象，并将替换后的元素返回
（5）int indexOf(Object o) 返回对象o在list 集合出现的位置索引
（6）int lastIndexOf(Object o) 返回对象o 在list 集合中最后一次出现的位置索引
（7）List subList(int fromIndex,int toIndex) 返回从索引fromIndex（包括） 到toIndex（不包括）处所有元素集合组成的子集合。

2.2、ArrayList集合
import  java.util.*;
public class Test{
    public static void main(String [] args) {
    ArrayList list = new ArrayList();  //创建ArrayList集合
    list.add("num_1");
    list.add("num_2");
    list.add("num_3");
    list.add("num_4");
    System.out.println("长度：" + list.size); //获取集合元素个数
    System.out.println("第二个元素：" + list.get(1));
    }
}

运行结果：
长度：4
第二个元素是：num_2

2.3、LinkedList 集合

1）前面的ArrayList 集合查询速度快，但是增删时的效率较低，为了克服这种局限性，可以使用List 接口另一个实现类LinkedList。
2）该集合维护一个双向链表，链表中的每一个元素都是使用引用的方式来记住它的前一个元素和后有一个元素。从而可以将所有的元素彼此相连。
3）增加或者删除一个元素，只需要修改这种链接关系即可。

（1）void add(int index， E element) 在列表指定的位置插入制定的元素
（2）void addFirst(Object o) 将指定元素插入此列表的开头
（3）void addLast(Object o) 将指定元素插入列表结尾

import java.util.*;
public class Test {
    public static void main (String [] args) {
    LinkedList link = new LinkedList();//创建LinkedList集合
    link.add("num_1");
    link.add("num_2");
    link.add("num_3"); 
    System.out.println(link.toString());

    link.add(3,"num_three");//向集合中指定位置插入元素
    link.addFirst("First");//向集合中第一个位置插入元素
        System.out.println(link);
        System.out.println(link.getFirst());//取出该集合中的第一个元素 

    link.remove(3);  //移除该集合中指定位置的元素
    link.removeFirst();//移除该集合中第一个元素
    System.out.println(link);
    }
}
2.4、Iterator接口

1）Collection Map 主要用于存储元素，而Iterartor主要用于迭代访问（遍历）

import java.util.*;
public class Test {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();//创建ArrayList集合
        list.add("data_1");
        list.add("data_2");
        list.add("data_3");
        liat.add("data_4");

        Iterator it = list.iterator();//获取Iterator对象
        while(it.hasNext()) {
            Object obj = it.next();//取出ArrayList集合中是否存在下一个元素。
        System.out.println(obj);
        }
    }
}
2.5、foreach 循环

1）格式
for(容器中元素类型 临时变量 ： 容器变量) {
执行语句
}

import java.util.ArrayList;
public class Test {
    public static void main(String [] args) {
    ArrayList list = new ArrayList(); //创建ArrayList集合
    list.add("Jack");//向ArrayList 集合中添加字符串元素
    list.add("Rose");
    list.add("Tom");
        for(Object obj:list) { //使用foreach循环遍历ArrayList对象
           System.out.println(obj);//取出并打印ArrayList集合中的元素

        }
    }
}

运行：
Jack Rose Tom

2.6、Listlterator 接口

1）定义了一个ListIterator 迭代器，它在hasNext()方法，next()方法的基础之上，还多了很多别的方法。
（1） void add(Object o) 将指定的元素插入列表（可选操作）
（2）boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回true
(3) Object previous() 返回列表中的前一个元素
（4）void remove 从列表中移除由next或者 previous 返回的最后一个元素（可选操作）

import  java.util.*;
public class Test{
    public static void main(String [] args) {
    ArrayList list = new ArrayList();
    list.add("data_1");
    list.add("data_2");
    list.add("data_3");
    System.out.println(list); 

    ListIterator it = list.listIterator(list.size()); //获得ListIterator 对象
    while (it.hasPrevious()) {//判断该对象中是否有上一个元素
        Object obj = it.previous();//迭代该对象的上一个元素
        Syatem.out.print(obj + " ");//获取并打印该对象的元素 
    }
    }

}

运行：
data_1 data_2 data_3

data_3 data_2 data_1

3、Set接口

1）Set接口中元素无序，并且都会以某种规则保证存入的元素不重复出现。
2）Set 接口主要实现两个类，分别是HashSet 和 TreeSet 。
3)其中HashSet 是根据对象的哈系值确定元素在集合中的存储位置，因此有良好的存取和查找性能。
4） TreeSet 则是以二叉树 的方式来存储元素，它可以实现集合中的元素进行排序。

3.1HashSet 集合接口

1）HashSet 集合是set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的。
2）添加一个对象时,首先调用hashCode()方法来确定元素的存储位置。
3）然后调用对象的equals()方法来确保该位置没有重复元素。

import java.util.*;
public class Test{
    public static void main(String[] args) {
    HashSet set = new HashSet();//创建HashSet 集合
    set.add("Tack"); 
    set.add("Eve");
    set.add("Rose");
    set.add("Rose");  //向Set 集合中添加重复元素

    Iterator it = set.iterator(); //获取Iterator 对象
    while (it.hasNext()) {
    Object obj = it.next(); //如果有元素，就通过迭代器的next()方法获取元素。
    System.out.println(obj);
    }
    }
}

运行：
Jack
Rose
Eve

（1）我们可以看到HashSet 集合并没有按照顺序，打印数据。
（2）我们添加了两个Rose 但是只有一个打印出来。

HashSet 首先会根据数据 调用 hashCode()，来确定存储位置，判断此位置有没所有数据。
没有数据就存储，有数据就调用equals()函数，判断这两个数据是不是一样的。如果一样就舍弃存放。

3.2TreeSet 集合 二叉树 接口

1)保证存储的数据没有重复的数据，并且可以对元素排序。
2)二叉树按照左子树小于又子树的方法排序。

import java.util.*;
public class Test{
    public static void main(String[] args) {
    TreeSet ts = new TreeSet();//创建TreeSet 集合
    ts.add("Jack"); 
    ts.add("Helean");
    ts.add("Helean");
    ts.add("Eve");  //向ts 集合中添加重复元素

    Iterator it = set.iterator(); //获取Iterator 对象
    while (it.hasNext()) {
    Object obj = it.next(); //如果有元素，就通过迭代器的next()方法获取元素。
    System.out.println(obj);
    }
    }
}

运行：
Eve
Helean
Jack

4、Map 接口

1）Map 接口是一个双列集合，它的每个元素都包含一个键对象Key 和一个值对象Value.
(1) void put(Object key,Object value) 将指定的值与此映射中的指定的键关联（可选操作）
（2）Object get(Object Key) 返回指定键所映射的值，如果次映射不包含该键的映射关系返回Null
（3）boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回true
(4) boolean containsValue(Object value) 如果此映射包含一个或多个键映射到指定值，则返回true.
(5)Set keySet() 返回此映射中包含的键的set 视图
（6）Collection values() 返回此映射中包含的值的Collection视图
（7）Set

4.1、HashMap 集合

1）HashMap 集合是Map 接口的一个实现类，它用于存储键值映射关系，但必须保证不会重复出现键。
2）简而言之：键相同，值覆盖。

import java.util.*;
public class Test{
    public static void main(String[] args) {
    Map map = new HashMap();//创建Map 集合
    map.put("1","jack");//存储键值
    map.put("2","Rose");
    map.put("3","Lucy");
    Set keySet = map.keySet(); //获取键的集合
    Iterator  it = keySet.iterator();//迭代键的组合

    while (it.hasNext()) {
    Object key = it.next(); //如果有元素，就通过迭代器的next()方法获取元素。
    Object value = map.get(key); //获取键所对应的值
    System.out.println(key+":"+value);
    }
    }
}

运行：
3：Lucy
2：Rose
1:Jack

这只是一种获取键值的方法。

4.2、TreeMap 集合

1）TreeMap 是通过二叉树 的原理来保证的键的唯一性的。

import java.util.*;
public class Test{
    public static void main(String[] args) {
    TreeMap tm = new TreeMap();//创建TreeMap 集合
    tm.put("1","jack");//存储键值
    tm.put("2","Rose");
    tm.put("3","Lucy");
    Set keySet = tm.keySet(); //获取键的集合
    Iterator  it = keySet.iterator();//迭代键的组合

    while (it.hasNext()) {
    Object key = it.next(); //如果有元素，就通过迭代器的next()方法获取元素。
    Object value = map.get(key); //获取键所对应的值
    System.out.println(key+":"+value);
    }
    }
}

运行：
1：Jack
2：Rose
3：Lucy

5、泛型

1）格式：
ArrayList <参数化类型> list = new ArrayList<参数化类型>();

import java.util.ArrayList;
public class Test {
    public static void main (String[] args) {
    ArrayList<String>list = new ArrayList<String>()；//创建ArrayList集合，使用泛型
    list.add("String");
    list.add("Collection");

    for(String str:list) {//遍历集合
        System.out.println(str); //强制转换String 类型
        }
    }
}

8、Collections 工具类

Collections 类提供了大量的方法用于对集合中的元素进行排序、修改、查找等操作。

(1)static boolean addall(Collection 

import java.util.*;
public class Test {
    public static void main (String[] args) {
    ArrayList list = new ArrayList();
    Collections.addAll(list,"c","z","b","k");//添加元素
    System.out.println("排序前：" + list);  //排序前输出

    Collections.reverse(list);//反转集合
    System.out.println("反转后：" + list);  //反转后输出

    Collections.sort(list);//按自然顺序排列
    System.out.println("按自然顺序排列：" + list);  

    Collections.shuffle(list);//洗牌后
    System.out.println("洗牌后：" + list);
    }
}

运行：
排序前：c,z,b,k
反转后：k,b,z,c
按自然顺序排列：b,c,k,z
洗牌后：k,c,b,z

一些查找、替换操作。
（1）static int binarySearch(List list, Object key) 使用二分法搜索指定的对象在list 集合中的索引，查找的List 集合中的元素必须是有序的。

（2）static Object max(Collection col) 根据元素的自然顺序，返回给定的集合中最大的元素

（3）static Object min(Collection col) 根据元素的自然顺序，返回给定集合中的最小的元素

（4）static boolean replaceAll(List list,Object oldVal , Object newVal) 用一个新的newVal 替代List 集合中所有的旧oldVal.

import java.util.*;
public class Test {
    public static void main (String[] args) {
    ArrayList list = new ArrayList();
    Collections.addAll(list,-3,2,9,5,8);
    Syatem.out.println("集合中的元素：" + list);

    Syatem.out.println("集合中的最大元素：" + Collections.max(list));

    Syatem.out.println("集合中的最小元素：" + Collections.min(list));

    Collections.replaceAll(list,8,0);//将集合中的8 0 调换
    Syatem.out.println("替换后的集合：" + list);
    }
}

运行：

集合中元素：-3 2 9 5 8
集合中的最大元素：9
集合中的最小元素：-3
替换后的集合：-3 2 9 5 0

9、Arrays 工具类

一个专门操作数组的工具类

1)使用Arrays.sort() 的方法排序
import java.util.*;
public class Test {
    public static void main (String[] args) {
    int [] arr = {9,8,3,5,2}; //初始化一个数组
    System.out.print("排序前：");
    printArray(arr); //打印原数组

    Arrays.sort(arr); //调用Arrays的方法进行排序
    System.out.print("排序后：");
    printArray(arr); //打印排序后数组
    }

    public static void printArray(int[] arr) { //定义打印数组方法
    System.out.print("[");
    for (int x= 0;x<arr.lerngth;x++) {
        if (x!=arr.length;x++) {
            System.out.print(arr[x] + " ");
            } else {
            Syetem.out.println(arr[x]+"]");
            }
        }
    }
}

运行：
排序前：[9,8,3,5,2]
排序后：[2,3,5,8,9]

2）Arrays.binarySearch() 二分法查找
import java.util.*;
public class Test {
    public static void main (String[] args) {
    int [] arr = {9,8,3,5,2}; //初始化一个数组

    Arrays.sort(arr);  //调用排序方法，对数组排序{2 3 5 8 9}

    int index = Arrays.binarySearch(arr,3); //查找指定元素
    Sysytem.out.print("数组排序后3的索引是：" + index);
    }
}

运行：
数组排序后3的索引是：1

使用二分法查找 首先要对其进行排序

3)Arrays.copyOfRange() 数组的拷贝
import java.util.*;
public class Test {
    public static void main (String[] args) {
    int [] arr = {9,8,3,5,2}; //初始化一个数组
    //从索引1开始拷贝，拷贝7-1 个数
    int [] copied = Arrays.copyOfange(arr,1,7);
    for (int i = 0;i< copied.lenth;i++) {
        System.out.print(copied[i] + " ");
    }
    }
}

运行：8 3 5 2 0 0

4）Array.fill() 数组的全替换
import java.util.*;
public class Test {
    public static void main (String[] args) {
    int [] arr = {9,8,3,5,2}; //初始化一个数组

    Arrays.fill(arr,8); //用8 替换数组中每一个值
    for (int i = 0;i< arr.lenth;i++) {
        System.out.print(arr[i] + " ");
    }
    }
}

运行： 8 8 8 8 8

5)、Array.toString() 把数组转换字符串
import java.util.*;
public class Test {
    public static void main (String[] args) {
    int [] arr = {9,8,3,5,2}; //初始化一个数组

    String arrString = Arrays.toString(arr);//使用toString（）方法将数组转换字符串
    System.out.print(arrString);
    }
}

运行： 9 8 3 5 2

参考文档：
Java基础入门　传智博客高教产品研发部　

本人郑重声明，本博客所著文章、图片版权归权利人持有，本博只做学习交流分享所用，不做任何商业用途。访问者可將本博提供的內容或服务用于个人学习、研究或欣赏，不得用于商业使用。同時，访问者应遵守著作权法及其他相关法律的规定，不得侵犯相关权利人的合法权利；如果用于商业用途，须征得相关权利人的书面授权。若以上文章、图片的原作者不愿意在此展示內容，请及时通知在下，將及时予以刪除。

标签：

相关文章