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();
    }
}

你可能感兴趣的:(Java,数据结构,字符串,java,hashmap,map)