投稿
  1. 首页
  2. java

java 集合总结

code • 2022-5-6 • java • 阅读 54

java 集合总结,第1张

集合 集合类：提供了一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

/*编写有错误之处欢迎指出*/

一.Collection（接口）：单列集合

创建Collection集合对象：

import java.util.ArrayList;
import java.util.Collection;
public class jihe {
    public static void main(String[] args){
        Collection c = new ArrayList();
        c.add("hello");
        c.clear();
        System.out.println(c.contains("hello"));
        System.out.println(c.isEmpty());
        System.out.println(c.size());
        System.out.println(c);
    }
}
方法名说明
add（E obj）将指定的对象添加到该集合中
remove（Object o）从集合中移除指定的元素
clear（）清空集合中的元素
contains（Object o）判断集合中是否存在指定的元素
isEmpty（）判断集合是否为空
size（）集合的长度，也就是集合中元素的个数

Colletion集合的遍历

  • lterator ：迭代器，集合的专用遍历方法

  • E next（）：返回迭代器的下一个元素

  • boolean hasNext（）：如果迭代具有更多的元素，返回true

  • 普通for循环

  • 增强for循环

    import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class jihe {
    public static void main(String[] args){
        Collection c = new ArrayList();
        c.add("hello");
        c.add("world");
        Iterator it = c.iterator();//迭代器循环（集合的专用遍历方法）
        while(it.hasNext())
        {
            String s = it.next();
            System.out.println(s);
        }
    }
}

1.List集合

  • 特点：有序集合，用户可以精确控制列表中每个元素的插入位置。用户可以通过索引访问元素，并搜索列表中的元素

  • 与Set集合不同，列表通常允许重复的元素

  • 有序：存储和取出的元素顺序一致

  • 可重复：存储的元素可重复

  • 增强for循环：简化数组和Collection集合的遍历

  • 格式：for（元素数据类型 变量名 ：数组或者Collection集合）

    { //在此使用变量即可，该变量就是元素

    }

    int[] arr = {1,2,3,4,5};//int型数组增强for循环
for(int i : arr){
    System.out.println(i);
}
String[] strArray = {"hello","world","java"};//String型数组增强for循环
for(String s: strArray){
    System.out.println(s);
}
List list = new ArrayList();//集合增强for循环（最方便的遍历方式）
list.add("hello");
list.add("world");
for(String s :list){
    System.out.println(s);
}
for(int i=0;i < list.size() ;i++)//普通for循环(带有索引的遍历方式)
{
    String s = list.get(i);
    System.out.println(s);
}

  • 方法名说明
    void add（int index,E element)在此集合中的指定位置插入指定的元素
    E remove(int index)删除指定索引处的元素，返回被删除的元素
    E set（int index , E element）修改指定索引处的元素，返回被修改的元素
    E get（int index）返回指定索引处的元素

1.1 ArrayList实现类

  • 由ArrayList类实现的List集合采用数组结构保存对象

  • 数组结构的优点是:便于对集合进行快速的随机访问

  • 数组结构的缺点是:向指定索引位置插入对象和删除指定索引位置对象的速度较慢

  • 当作数据结构中数组的存储方式看

    public class ArrayListDemo{
    public static void main(String[] arge){
        //创建ArrayList集合对象
        ArrayList array = new ArrayList<~>();
        //创建学生对象
        Student s1 = new Student(name:"小明",age:18);
        Student s2 = new Student(name:"小美",age:15);
        //把学生添加到集合中
        array.add(s1);
        array.add(s2);
        //迭代器，集合特有的遍历方式
        Iterator it = array.iterator;
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge);
        }
        //普通for循环遍历
        for(int i =0 ;i < array.size(); i++）
        {
            String s = array.get(i);
            System.out.println(s.getName()+","+s.getAge);
        }
        //增强for循环
        for(Student s :array){
            System.out.println(s.getName()+","+s.getAge);
        }
    }
}

1.2 LinkeList实现类

  • 由LinkedList类实现的LIst集合采用链表结构保存对象

  • 链表结构的优点：便于向集合中插入和删除对象

  • 链表结构的缺点：随机访问对象的速度较慢

  • 当作数据结构中数组的存储方式看

    方法名说明
    public void addFirst(E e)在该列表开头插入指定的元素
    public void addLast(E e)将指定的元素追加到此列表的末尾
    public E getFirst()返回此列表中的第一个元素
    public E getLast()返回此列表中的最后一个元素
    public E removeFirst()从此列表中删除并返回第一个元素
    public E removeLast()从此列表中删除并返回最后一个元素
    public class LinkedListDemo{
    public static void main(String[] args){
        //创建集合对象
        LinkedList linkedList = new LinkedList();
        //添加集合对象
        linkedList.add("hello");
        linkedList.add("world");
        //add方法
        linkedList.addFirst(e:"javase");
        linkedList.addLast(e:"javase");
        //get方法
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
        //remove方法
        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList.removeLast());
​
        System.out.println(linkedList);
    }
}

2.Set集合

  • 不包含重复元素的集合

  • 没有带索引的方法，所以不能使用普通for循环遍历

  • set集合为集类型。集是最简单的一种集合之一，存放于集合的对象不按特定方式排序，只是简单地把对象加入集合中，类似于向口袋里放东西

  • 哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

2.1 HashSet

  • 对集合的迭代顺序不作任何保证

  • 能够快速定位集合中的元素

  • 没有带索引的方法，所以不能使用普通for循环遍历

  • 不包含重复元素的集合

  • 添加到由HashSet类实现的Set集合中的对象，需要重新实现equals()方法，从而保证插入集合中对象的标识的唯一性

  • 由HashSet类实现的Set集合按照哈希码排序，根据对象的哈希码确定对象的存储位置，所以添加到由HashSet类实现的Set集合的对象，还需要重新实现hashCode()方法，从而保证插入集合中的对象能够合理的分布在集合中，以便于快速定位集合中的对象

public class SetDemo{
    public static void main(String[] args){
        //创建集合对象
        HashSet set = new HashSet();
        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素的集合
        set.add("world");
        //遍历
        for(String s : set){
            System.out.println(s);
        }
    }
}

2.2 LinkedHashSet集合特点

  • 哈希表和链表实现的Set接口，具有可预测的迭代次序

  • 有链表保证元素有序，也就是说元素的存储和取出顺序是一致的

  • 有哈希表保证元素唯一，也就是说没有重复的元素

    public class LinkedHashSet{
    public static void main(String[] args){
        //创建集合对象
        LinkedHashSet linkedHashSet = new linkedHashSet();
        //添加元素
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        //遍历集合
        for(String s : linkedHashSet){
            System.out.println(s);
        }
    }
}

2.3 TreeSet

  • 不仅实现了Set接口，还实现了java.util.SortedSet接口，从而保证在遍历集合时按照递增的顺序获得对象

  • 递增排列对象的一种方式是按照自然顺序递增排序，需要实现Comparable接口

    • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序

    • 自然排序，就是让元素所属的类实现Comparable接口，重写comparableTo(T o)方法

    • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件写

  • 递增排列对象的另一种方式是按照指定比较器递增排序

    • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的

    • 比较器排序，就是让集合构造方法接受Comparator的实现类对象，重写compara（T o1，T o2）方法

    • 重写方法是，一定要注意排序规则必须按照要求的主要条件和次要条件写

  • 没有带索引的方法，所以不能使用普通for循环遍历

  • 不包含重复元素的集合

public class TreeSetDemo{
    public static void main(String[] args){
        //创建集合对象
        TreeSet ts = new TreeSet();
        //添加对象
        ts.add(10);
        ts.add(20);
        ts.add(30);
        ts.add(40);
        ts.add(50);
        //遍历集合
        for(Integer i : ts)
        {
            System.out.println(i);
        }
    }
}
//自然顺序递增排序
public class TreeSetDemo{
    public static void main(String[] args){
        //创建集合对象
        TreeSet ts = new TreeSet();
        //创建学生对象
        Student s1 = new Student("xiaoming",18);
        Student s2 = new Student("xiaoli",21);
        Student s3 = new Student("xiaowang",19);
        Student s4 = new Student("xiaohong",20);
        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        //遍历集合
        for(Student s : ts){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}
public class Student implements Comparable{
    private String name;
    private int age;
    public Student(){}
    public Student(String name , int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName(){return name;}
    public void setName(String name){this.name = name;}
    public int getAge(){return age;}
    public void setAge(int age){this.age = age};
    @override
    public int compareTo(Student s){
        //return 0    所比较的元素相等
        //return 1    升序存储
        //return -1   降序存储
        //按照年龄从小到大排序
        int num = this.age - s.age;
        //年龄相同时，按照姓名的字母顺序排序
        int num2 = num == 0?this.name.compareTo(s.name):num;
        return num2;
    }
}
//比较器递增排序
public class TreeSetDemo{
    public static void main(String[] args){
        //创建集合对象
        TreeSet ts = new TreeSet(new Comparator() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge()-s2.getAge();
                int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        //创建学生对象
        Student s1 = new Student("xiaoming",18);
        Student s2 = new Student("xiaoli",21);
        Student s3 = new Student("xiaowang",19);
        Student s4 = new Student("xiaohong",17);
        Student s5 = new Student("xiaohong",21);
        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        //遍历集合
        for(Student s : ts){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}
public class Student {
        private String name;
        private int age;
        public Student(){}
        public Student(String name , int age)
        {
            this.name = name;
            this.age = age;
        }
        public String getName(){return name;}
        public void setName(String name){this.name = name;}
        public int getAge(){return age;}
        public void setAge(int age){this.age = age;};
​
}
​

二.Map集合（接口）

  • interface Map K:键的类型 V：值的类型

  • 将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值

创建Map集合的对象

  • 多态的方式

  • Map接口的常用实现类有HashMap和TreeMap

  • HaspMap通过哈希码对其内部的映射关系进行快速查找，而TreeMap中的映射关系存在一定的顺序

  • 如果经常需要添加、删除和定位映射关系，建议利用HashMap类实现Map集合，使用时需要重写作为主键对象类的hashCode()方法

    • 重写hashCode()时有以下两条原则

      （1）不唯一原则：不必为每个对象生成一个唯一的哈希码，只要通过hashCode()方法生成的哈希码能够利用get()方法得到put()方法添加的映射关系就可以

      （2）分散原则：生成的哈希码的算法应尽量使哈希码的值分散一些，不要很多哈希码值都集中在一个范围内，这样有利于提高由HashMap类实现的Map集合的性能

    package util;
​
import java.util.HashMap;
import java.util.Map;
​
public class map {
    public static void main(String[] args)
    {
        //创建集合对象
        Map map = new HashMap();
        //将指定的值与该映射中指定的键关联
        map.put("xiaoming","小明");
        map.put("xiaoli","小李");
        map.put("xiaohong","小红");
        System.out.println(map);
    }
}
    ​
方法名说明
V put(K key,V value)添加元素
V remove（Object key）根据键删除键值对元素
void clear()移除所有的键值对元素
boolean containsKey(Object key)判断集合是否包含指定的键
boolean containsValue（Object value）判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数
V get(Object key)根据键获取值
Set(K) keySet()获取所有值的集合
Collection values()获取所有值的集合
Set> entrySet()获取所有键值对对象的集合
public class MapDemo{
    public static void main(String[] args){
        map.put("xiaoming","小明");
        map.put("xiaoli","小李");
        map.put("xiaohong","小红");
        //获取所有键的集合，用keySet（）方法实现
        Set keySet = map.keySet();
        for(String key : keySet){
            //根据键去找值，用get方法去实现
            String value = map.get(key);
            System.out.println(key+","+value);
        }
    }
}

  • Map集合的遍历

    //方法一
​
package util;
​
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class map {
    public static void main(String[] args)
    {
        //创建集合对象
        Map map = new HashMap();
        //将指定的值与该映射中指定的键关联
        map.put("xiaoming","小明");
        map.put("xiaoli","小李");
        map.put("xiaohong","小红");
        //获取所有键值对对象的集合
        //相当于获取你的学生卡，从学生卡里获取你的学号和姓名
        Set> entrySet = map.entrySet();
        for(Map.Entry me :entrySet){
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+","+value);
        }
    }
}
​
    //方法二
​
package util;
​
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class map {
    public static void main(String[] args)
    {
        //创建集合对象
        Map map = new HashMap();
        //将指定的值与该映射中指定的键关联
        map.put("xiaoming","小明");
        map.put("xiaoli","小李");
        map.put("xiaohong","小红");
        Set keySet = map.keySet();
        for(String key : keySet){
            String value = map.get(key);
            System.out.println(key+","+value);
        }
    }
}
​

  • TreeMap类

    • 集合需要进行有序的遍历输出，建议使用TreeMap类

    • 不允许键对象为null，因为集合中的映射关系是根据键对象按照一定顺序排列的

    方法名说明
    comparator()获得对该集合采用的比较器
    firstKey()返回在集合中的排序的第一位的键对象
    lastKey()返回在集合中的排序的最后一位的键对象
    headMap(K toKey)截取在集合中的排序是键对象toKey（不包括）之前的所有映射关系，重新生成一个SortedMap集合并返回
    subMap(K fromKey ,K toKey)截取在集合中的排序是键对象fromKey（包括）和toKey(不包括)之间的所有映射关系，重新生成一个SortedMap集合并返回
    tailMap(K fromKey)截取在集合中的排序是键对象fromKey（包括）之后的所有映射关系，重新生成一个SortedMap集合并返回
    //声明
public class jihe{
    public static void main(String[] args){
        TreeMap treeMap = new TreeMap();
    } 
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/798639.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-06
下一篇 2022-05-06

发表评论

登录后才能评论

评论列表（0条）

保存