集合——Map集合、List集合、Set集合

java进阶(一)

集合

集合的定义

Java集合类存放于java.util包中，是一个用来存放对象的容器。
1. 集合只能存放对象。比如你存了一个int型数据1放入集合中，其实它是自动转换成Integer类后存入的，Java中每一个基本类型都有对应的引用类型。
2. 集合存放的是多个对象的引用，对象本身还是放在对内存中。
3. 集合可以存放不同类型，不限数量的数据类型。
Java集合可分为Set、List和Map三种大体系
1. set：无序、不可重复的集合
2. List：有序、可重复集合
3. Map：具有映射关系的集合

HashSet

HashSet是Set接口的典型实现，大多数时候使用set集合时都是用这个实现类。大多数时候说的set集合指的都是HashSet。

HashSet的特点：

不能保证元素的排列数序
不可重复
HashSet不是线程安全的
集合元素可以是null

HashSet的用法：

当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置。

HashSet不可重复指的是hashcode不相同

HashSet类实现set接口，set接口继承Collection接口

set集合常用的方法，代码示例：

package set;

import java.util.HashSet;
import java.util.Set;

public class Demo01 {
    public static void main(String[] args) {
        Set set=new HashSet();
        set.add("a");//给set集合内增加一个元素
        set.add(1);
        System.out.println(set);
        set.remove(1);//删除set集合中的1
        System.out.println(set);
        System.out.println(set.contains("a"));//判断set集合中是否有a
        set.clear();//清空集合
        System.out.println(set);
    }


}

遍历set集合，代码示例：

 package set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Demo02 {
    public static void main(String[] args) {
        Set set=new HashSet();
        /*
        set接口类型的引用指向一个实现了该接口的对象，HashSet类重写了set接口中的许多方法，
        set接口的类型的引用如果想要调用方法，调用的都是实现类中重写过后的方法，因为接口中的方法都是抽象的，无法调用。
         */
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        Iterator iterator=set.iterator();
        //使用迭代器对集合进行遍历输出
        while (iterator.hasNext()){
            System.out.print(iterator.next()+" ");
        }
        System.out.println();
        //使用for...each对set集合进行遍历循环输出
        for(Object o:set){//这个for...each循环的意思是把set的值取出来赋值给o，直到把set的所有值循环一遍
            System.out.println(o+" ");
        }
        System.out.println();
        //得到set集合长度
        System.out.println(set.size());
    }
}

编译结果：

[null, a, b, c, d]
null a b c d
null a b c d
5

TreeSet

TreeSet是SortedSet接口的实现类，TreeSet可以确保几何元素处于排序状态。TreeSet支持两种排序方法排序方法：自然排序和定制排序

如果需要实现定制排序，则需要创建TreeSet集合对象时，提供一个Comparator接口的实现类对象。由该Comparator对象负责集合元素的排序逻辑

自然排序代码示例：

package set;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

//TreeSet
public class Demo04 {
    public static void main(String[] args) {
        Set<Integer> set=new TreeSet<Integer>();
        //TreeSet自然排序
        set.add(2);
        set.add(6);
        set.add(4);
        set.add(3);
        set.add(7);
        set.add(1);
        System.out.print(set);
        System.out.println();
        set.remove(3);
        set.contains(1);
        //使用迭代的方式来遍历集合
        Iterator iterator=set.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next()+" ");
        }
        System.out.println();
        //使用foreach的方法来遍历集合
        for (Integer i:set) {
            System.out.print(i+" ");
        }
        System.out.println();
    }
}

定制排序代码示例：

Person类：

package set.Demo05;

import java.util.Comparator;

public class Person implements Comparator<Person> {//把Person对象存到TreeSet集合中并按照年龄大小排序
    String name;
    int age;
    public Person(){}
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    public int compare(Person o1, Person o2) {//按照年龄的大小正序排列
        if (o1.age > o2.age){
            return 1;
        }else if(o1.age<o2.age){
            return -1;
        }else{
            return 0;
        }
    }
}

主方法：

package set.Demo05;

import java.util.Set;
import java.util.TreeSet;

public class Application {
    public static void main(String[] args) {

        Person person=new Person("周一",21);
        Person person1=new Person("周二",22);
        Person person2=new Person("周三",20);
        Person person3=new Person("周四",23);
        Person person4=new Person("周五",24);
        Set<Person> set=new TreeSet<Person>(new Person());
        set.add(person);
        set.add(person1);
        set.add(person2);
        set.add(person3);
        set.add(person4);
        for (Person p:set) {
            System.out.println(p.name+"   "+p.age);
        }

    }
}

定制排序的关键代码示例：

 public int compare(Person o1, Person o2) {//按照年龄的大小正序排列
        if (o1.age > o2.age){
            return 1;
        }else if(o1.age<o2.age){
            return -1;
        }else{
            return 0;
        }
    }

List集合

List代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引
List允许使用重复元素，可以通过索引来访问指定位置的集合元素。
List默认按元素的添加顺序设置元素的索引。

List集合里添加了一些根据索引来操作几何元素的方法

ArrayList实现了List接口，List继承了Collection接口
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。

代码示例：

package set;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo06 {
    public static void main(String[] args) {
    List<String> list=new ArrayList<String>();
    list.add("b");//第一个，索引下标0
    list.add("c");//索引下标1
    list.add("a");//索引下标2
    list.add("f");//索引下标3
    list.add("e");//索引下标4
    list.add("a");//索引下标5，允许使用重复元素
    System.out.println(list);
    System.out.println(list.get(2));//通过索引来访问指定位置的集合元素
    list.add(2,"z");
    System.out.println(list);
    list.remove(1);//根据指定的索引下标移除元素
    System.out.println(list);

    List<String> i=new ArrayList<String>();
    i.add("12");
    i.add("78");
    i.add("32");
    list.addAll(2,i); //在指定索引下标的位置插入集合
    System.out.println(list);
    System.out.println(list.indexOf("a"));//获取指定元素在集合中第一次出现的索引下标
    System.out.println(list.lastIndexOf("a"));//获取指定元素在集合中最后一次出现的索引下标
    list.set(1,"f");//根据指定的索引下标修改元素
    System.out.println(list);
    //根据索引下标的起始位置截取一段元素形成一个新的集合，截取的时候，包含开始的索引不包括结束时的索引
    List<String> sublist=list.subList(2,4);//取索引下标大于等于2小于4的元素
    System.out.println(sublist);
    System.out.println("************");
    //foreach循环遍历list集合
        for (String s:list) {
            System.out.println(s);
        }
    System.out.println("************");
    //用迭代的方法遍历list集合
        Iterator iterator=list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("list集合的长度："+list.size());//list集合的长度
     }

}

Map集合

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组用于保存Map里的Value。

Map中的key和value都可以是任何引用类型的数据，Map中的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较中返回false

Key和Value之间存在单向一对一关系，即通过指定的key总能找到唯一的，确定的Value

Map集合示例代码：

  package set;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo07 {
    public static void main(String[] args) {
    Map<String,Integer> map=new HashMap<String,Integer>();
    map.put("b",1);//添加数据
    map.put("a",5);
    map.put("u",7);
    map.put("w",6);
    map.put("r",2);
    System.out.println(map);
    System.out.println(map.get("u"));//根据key取值
    map.remove("r");//根据kay移除键值对
        System.out.println(map);
        System.out.println(map.size());//map集合长度
        System.out.println(map.containsKey("a"));//判断当前的map集合是否包含指定的key
        System.out.println(map.containsValue(2));//判断当前的map集合是否包含指定的value
        //map.clear();清空集合
        //遍历map集合
        map.keySet();//获取map集合的key的集合
        map.values();//获取集合所有value值
        //map.keySet()的返回值是一个set集合,把它变成set集合，遍历寻找key，再通过key来找value
        Set<String> key=map.keySet();
        for (String k:key) {
            System.out.print(k+"=");
            System.out.println(map.get(k));
        }
        //通过map.entrySet()遍历循环
        System.out.println("***********");
        Set<Map.Entry<String,Integer>> m=map.entrySet();
        for (Map.Entry entrys:m) {
            System.out.println(entrys.getKey()+"="+entrys.getValue());
        }
        //通过迭代器来遍历循环
        Set keyset= map.keySet();
        Iterator iterator=keyset.iterator();
        while(iterator.hasNext()){
            Object key=iterator.next();
            System.out.print(key+" ");
            System.out.print(map.get(key));//通过键来找到值
            System.out.println();
    }

}

Collections工具类

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素，Java不提供直接继承自Collection的类，只提供继承子接口（List和Set）去继承Collection接口。

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

Collections中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。

排序操作：

reverse(List):反转List中元素的顺序
```
Collections.reverse(list);
```
shuffle(List):对List集合元素进行随机排序
```
Collections.shuffle(list);
```
sort(List):根据元素的自然顺序对指定List集合元素按升序排序
sort(List,Comparator):根据指定的Comparator产生的顺序对list集合元素进行排序
swap(List,int,int):将指定list集合中的i元素和j元素进行交换
```
Collections.swap(list,1,3);
```
Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素

Object max(Collection,Comparator)：根据Comperator指定的序列，返回给定集合中的最大元素

Object min(Collection)、Object min(Collection,Comparator)

//根据Comperator指定的序列，返回给定集合中的最大元素
 Student s=Collections.max(list1,new Student());
 System.out.println(s.age+" "+s.name);
 //根据Comperator指定的序列，返回给定集合中的最小元素
 Student s1=Collections.min(list1,new Student());
 System.out.println(s1.age+" "+s1.name);

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

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

代码示例：

package com.zjl.jihe.collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class Demo01 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("a");
        list.add("a");
        System.out.println(list);
        Collections.reverse(list);//反转list集合中的元素顺序
        System.out.println(list);
        Collections.shuffle(list);//对list集合元素进行随机排序
        System.out.println(list);
        Collections.sort(list);//对list集合进行升序排列，按字典顺序
        System.out.println(list);
        Student student=new Student(12,"周一");
        Student student2=new Student(13,"周二");
        Student student3=new Student(15,"周三");
        Student student4=new Student(14,"周四");
        Student student5=new Student(16,"周五");

        System.out.println();
        List<Student> list1=new ArrayList<Student>();
        list1.add(student);
        list1.add(student2);
        list1.add(student3);
        list1.add(student4);
        list1.add(student5);
        for (Student s:list1) {
            System.out.println(s.age+" "+s.name);
        }
        System.out.println("***************");
        //根据指定的Comparator产生的顺序对list集合元素进行排序
        Collections.sort(list1,new Student());
        for (Student s:list1) {
            System.out.println(s.age+" "+s.name);

        }
        System.out.println("*********");

        System.out.println("list集合的最大值为："+Collections.max(list));
        System.out.println("list集合的最小值为："+Collections.min(list));
        //根据Comperator指定的序列，返回给定集合中的最大元素
        Student s=Collections.max(list1,new Student());
        System.out.println(s.age+" "+s.name);
        //根据Comperator指定的序列，返回给定集合中的最小元素
        Student s1=Collections.min(list1,new Student());
        System.out.println(s1.age+" "+s1.name);
        //int frequency(Collection,Object):返回指定集合中指定元素出现的次数
        System.out.println(Collections.frequency(list,"a"));
        //使用新值替换list对象的所有旧值
        Collections.replaceAll(list,"a","z");
        System.out.println(list);
    }
}

Java Iterator(迭代器)

Java Iterator(迭代器)不是一个集合，它是一种用于访问集合的方法，可用于迭代ArrayList和HashSet等集合。

Iterator是Java迭代器最简单的实现，Listlterator是Collection API的接口，它扩展了Iterator接口。

迭代器it的两个基本操作是next，hasNext和remove。

调用it.next()会返回迭代器的下一个元素，并且更新迭代器的状态。

调用it.hasNext()用于检测集合中是否还有元素。

调用it.remove()将迭代器返回的元素删除。

public class Demo02{
    public static void main(String[] args){
        List<String> list=new ArrayList<String>();
        list.add("周一");
        list.add("周二");
        list.add("周三");
        list.add("周四");
        //使用迭代器来循环遍历集合
        //获取迭代器
        Iterator<String> it=list.iterator();
        while(it.hasnext()){
            System.out.println(it.next());
        }
    }
}

posted @ 2020-11-24 16:18 乐二啊阅读(230) 评论(0) 收藏举报

刷新页面返回顶部

乐儿啊