Java学习笔记（六）——集合

迭代器

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

class note{
    public static void main(String[] args) {
        ArrayList<String> al=new ArrayList<String>();
        al.add("java1");
        al.add("java2");
        al.add("java3");
        al.add("java4");
        
        //获取迭代器，用于取出集合中的元素
        //hasNext()判断当前元素是否为空
        //next()获取下一个元素
        //remove()删除当前元素元素
        for(Iterator<String> it=al.iterator();it.hasNext();){
            System.out.println(it.next());
        }
    }
}

---

基本方法

Collection

|–List:元素是有序的，元素可以重复，因为该集合体系有索引
List：特有方法。凡是可以操作角标的方法都是该体系特有的方法。

|–ArrayList：底层使用的是数组结构。特点：必须开辟连续空间，查询速度很快，增删稍慢。线程不同步。
|–Vector：底层使用的是数组数据结构。线程同步。被ArrayList替代了。
|–LinkedList：底层使用的是链表数据结构。特点：无需开辟连续空间，增删速度很快，查询稍慢。

|–Set:元素是无序的，元素不可以重复
Set集合的功能和Collection是一致的

|–HashSet：底层数据结构是哈希表

HashSet通过两个元素的两个方法hashCode和equals来保证元素的唯一性。如果元素的hashCode值相同，才会判断equals是否为true；如果元素的hashCode值不同，不会调用equals。

|–TreeSet：可以对Set集合中的元素进行排序。底层数据结构是二叉排序树。

保证元素唯一的依据compareTo方法return 0
①TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法，这种方式也称为元素的自然排序，或者叫做默认排序。
②TreeSet排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这是需要让集合自身具备比较性。在集合初始化时就有比较方式。
当两种排序都存在时，以第二种方式为主。

List集合特有的迭代器。ListIterator是Iterator的子接口

在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，
只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加、修改等，就需要使用其子接口，ListIterator。
该接口只能通过List集合的listIterator方法获取

---

Map集合

该集合存储键值对。保证键唯一性
Set底层就是使用了Map集合。

|–Hashtable：底层是哈希表数据结构，不可以存入null键和值。该集合线程同步。
|–HashMap：底层是哈希表数据结构，允许使用null键和值。该线程是不同步的。
|–TreeMap：底层是二叉树数据结构，线程不同步。可以用于给Map集合中的键进行排序。

---

部分特性

ArratList：如果没有向集合中添加任何元素时，容量为0；添加一个元素之后，容量为10；每次扩容大小是原来的1.5倍

HashMap:默认初始容量为16，加载因子0.75；当元素个数大于阈值时，会进行扩容，扩容后大小为原来的2倍

---

ArrayList基本方法（其他集合基本方法同下）

import java.util.ArrayList;

class note{
    public static void main(String[] args) {
        //创建一个集合容器
        ArrayList<String> al=new ArrayList<String>();

        //1.添加元素
        al.add("java1");
        al.add("java2");
        al.add("java3");
        al.add("java4");

        //打印集合
        System.out.println(al);

        //2.获取个数
        System.out.println("size:"+al.size());

        //3.删除元素
        al.remove("java2");
        System.out.println("size:"+al.size());
        System.out.println(al);

        //4.判断元素
        System.out.println(al.contains("java3"));
        System.out.println(al.isEmpty());
    }
}

---

ArrayList()练习一

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

class note{
    public static void main(String[] args) {
        ArrayList<String> al=new ArrayList<String>();
        al.add("java1");
        al.add("java2");
        al.add("java3");
        al.add("java4");
        al=single(al);
        System.out.println(al);
    }
    //ArrayList()去掉重复元素
    public static ArrayList single(ArrayList al) {
        ArrayList newal = new ArrayList();
        for (Iterator it = al.iterator(); it.hasNext(); ) {
            Object obj = it.next();
            if (!newal.contains(obj))
                newal.add(obj);
        }
        return newal;
    }
}

ArrayList()练习二

import java.util.ArrayList;
import java.util.Iterator;
/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素
例如：存人对象。同姓名同年龄，视为同一个人，为重复对象。
思路：
1.对人描述，将数据封装进入对象
2.定义容器，将人存入
3.取出

List集合判断元素是否相同，依据的是元素的equals方法。
 */
class Person{
    private String name;
    private int age;
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public boolean equals(Object obj){
        if(!(obj instanceof Person))
            return false;
        Person p=(Person)obj;
        System.out.println(this.name+"----"+p.name);
        return this.name.equals(p.name)&&this.age==p.age;
    }
}
class note{
    public static void main(String[] args) {
        ArrayList<Person> al=new ArrayList<Person>();
        al.add(new Person("java01",30));
        al.add(new Person("java02",31));
        al.add(new Person("java03",32));
        al.add(new Person("java04",33));
        al.add(new Person("java04",33));

        al=single(al);

        for(Iterator it=al.iterator();it.hasNext();){
            Person p=(Person)it.next();
            System.out.println(p.getName()+"--"+p.getAge());
        }
    }
    public static ArrayList single(ArrayList al) {
        ArrayList newal = new ArrayList();
        for (Iterator it = al.iterator(); it.hasNext(); ) {
            Object obj = it.next();
            if (!newal.contains(obj))
                newal.add(obj);
        }
        return newal;
    }
}

---

HashSet练习

import java.util.HashSet;
import java.util.Iterator;
/*
往hashSet集合中存入自定义对象
姓名和年龄相同为同一个人，视为重复元素
 */
class Person{
    private String name;
    private int age;
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public boolean equals(Object obj){
        if(!(obj instanceof Person))
            return false;
        Person p=(Person)obj;
        System.out.println(this.name+"----"+p.name);
        return this.name.equals(p.name)&&this.age==p.age;
    }
    public int hashCode(){
        System.out.println(this.name+"---hashCode");
        return name.hashCode()*age;
    }
}
class note{
    public static void main(String[] args) {
        HashSet<Person> hs=new HashSet<Person>();
        hs.add(new Person("java01",30));
        hs.add(new Person("java02",31));
        hs.add(new Person("java03",32));
        hs.add(new Person("java03",32));

        for(Iterator it=hs.iterator();it.hasNext();){
            Person p=(Person)it.next();
            System.out.println(p.getName()+"--"+p.getAge());
        }
    }
}

---

TreeSet练习

import java.util.Iterator;
import java.util.TreeSet;
//TreeSet存储数据需要实现Comparable接口
class note{
    public static void main(String[] args) {
        TreeSet<Student> ts=new TreeSet<Student>();//TreeSet<Student> ts=new TreeSet<Student>(new Mycompare());

        ts.add(new Student("java01",20));
        ts.add(new Student("java02",19));
        ts.add(new Student("java03",18));
        ts.add(new Student("java04",18));

        for(Iterator it=ts.iterator(); it.hasNext();){
            Student stu=(Student)it.next();
            System.out.println(stu.getName()+"--"+stu.getAge());
        }
    }
}
class Student implements Comparable{
    private String name;
    private int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    //默认排序
    public int compareTo(Object obj){
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s=(Student) obj;
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
            return this.name.compareTo(s.name);
        return -1;
    }
}
/*比较器排序
class Mycompare implements Comparator {
    public int compare(Object o1,Object o2){
        Student s1=(Student) o1;
        Student s2=(Student) o2;

        return s1.getName().compareTo(s2.getName());
    }
}*/

---

Map基本方法

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

class note{
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        //添加元素
        map.put("01","zhangsan1");
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");
        //判断元素
        System.out.println(map.containsKey("022"));
        System.out.println(map.isEmpty());
        //删除元素
        System.out.println(map.remove("022"));

        //获取Map集合中所有的值
        System.out.println(map.values());
        
        System.out.println(map);
    }
}

---

HashMap练习

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
学生属性：姓名、年龄（姓名和年龄相同视为同一学生，保证学生的唯一性）
思路：
1.描述学生
2.定义map容器，将学生作为键，地址作为值存入
3.获取map集合中的元素
 */
class Student implements Comparable<Student>{
    private String name;
    private int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int age(){
        return age;
    }
    public String toString(){
        return name+"--"+age;
    }
    public int compareTo(Student s){
        int num=new Integer(this.age).compareTo(new Integer(s.age));
        if(num==0)
            return this.name.compareTo(s.name);
        return num;
    }
    public int hashCode(Object obj){
        return name.hashCode()*age;
    }
    public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
        Student s=(Student) obj;
        return this.name.equals(s.name)&&this.age==s.age;
    }
}
class note{
    public static void main(String[] args) {
        HashMap<Student,String> hm=new HashMap<>();

        hm.put(new Student("lisi1",21),"beijing");
        hm.put(new Student("lisi2",22),"shanghai");
        hm.put(new Student("lisi3",23),"hangzhou");
        hm.put(new Student("lisi4",24),"zhengzhou");
        //第一种取出方式
        Set<Student> keySet=hm.keySet();
        for(Iterator<Student> it=keySet.iterator();it.hasNext();){
            Student stu=it.next();
            String addr=hm.get(stu);
            System.out.println(stu+"--"+addr);
        }
        //第二种取出方式
        Set<Map.Entry<Student,String>> entrySet=hm.entrySet();
        for(Iterator<Map.Entry<Student,String>> iter=entrySet.iterator();iter.hasNext();){
            Map.Entry<Student,String> me=iter.next();
            Student stu=me.getKey();
            String addr=me.getValue();
            System.out.println(stu+"----"+addr);
        }
    }
}

---

TreeMap练习

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
获取某一字符串中各字母出现的次数
思路：
1.将字符串转换成字符数组，因为要对每一个字母进行操作。
2.定义一个map集合，因为打印结构的字母有顺序，所以使用TreeMap集合。
3.遍历字符数组。
    将每一个字母作为键去查map集合；
    如果返回null，将该字母和1存入到map集合中；
    如果返回不是努力了，说明该字母在map集合已经存在并有对应次数；
    那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中
4.将map集合中的数据变成指定的字符串形式返回
 */
class note{
    public static void main(String[] args) {
        String s=charCount("ghsafgyghfhja");
        System.out.println(s);
    }
    public static String charCount(String str){
        char[] cha=str.toCharArray();
        TreeMap<Character,Integer> tm=new TreeMap<>();
        for(int x=0;x<cha.length;x++){
            if(cha[x]>='a'&&cha[x]<='z'||cha[x]>='A'&&cha[x]<='Z')
                continue;
            Integer value=tm.get(cha[x]);
            if(value==null)
                tm.put(cha[x],1);
            else{
                value=value+1;
                tm.put(cha[x],value);
            }
        }
        //System.out.println(tm);

        StringBuilder sb=new StringBuilder();
        Set<Map .Entry<Character,Integer>> entrySet=tm.entrySet();
        for(Iterator<Map.Entry<Character,Integer>> it=entrySet.iterator();it.hasNext();){
            Map.Entry<Character,Integer> me= it.next();
            Character ch=me.getKey();
            Integer value=me.getValue();
            sb.append(ch+"("+value+")");
        }
        return sb.toString();
    }
}