Java基础入门笔记06——String类和StringBuffer类，Java中的三大集合，Set集合，List集合，Map集合，Collection类

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

常用——类&&接口

String类和StringBuffer类

• String类不能改变串对象中的内容，每次操作后都产生一个新串
• StringBuffer类可以实现字符串动态改变，对原对象增删改查
• toCharArray（）：将字符串对象转换为字符数组
• length（）：获取字符串的长度

回顾

• length：获取数组长度
• size（）：获取集合内元素的个数

Comparator接口——待补充

equals（）和”==”的区别

equals（）仅判断值是否相等

“==”判断值还要判断引用是否相等

Java的三种集合

都是接口，需要具体类实现

1. 集合类存在于java.util包中，是一个用来存放对象的容器
2. 集合只能存放对象。如果存放int型数据，会自动转换为Integer类的对象存入。（Java中每一种基本类型都有对应的引用类型）
3. 集合中存放的是多个对象的引用，对象本身还是存放在堆内存。
4. 集合可以存放不同数据类型，不限数量的对象。

1.Set集合——无序，不可重复

HashSet类

• HashSet类实现了Set接口，Set接口继承于Collection接口
• 按照Hash算法存储集合元素——方便存取查找

特点：
不保证元素排列顺序，不可重复，不是线程安全的，集合元素可以存null

存储过程：
当HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，从而决定该对象在HashSet中的位置

notes：
如果两个元素的equals（）返回true，但是他们的hashCode（）值返回不一致，则hashSet将会把他们存储在不同的位置。
（这一点与不可重复不冲突，注意理解）

package setStudy1117;

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

public class test01 { 
   
    public static void main(String[] args) { 
   
        Set set = new HashSet();
        //添加元素add
        set.add(1);
        set.add("a");
        System.out.println(set);
        //删除元素
        set.remove(1);
        System.out.println(set);
        //判断是否包含元素——contains
        System.out.println(set.contains(1));
        //清空所有元素clear
        set.clear();
        System.out.println(set);
        //遍历集合————————
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        System.out.println(set);
		// 1.使用迭代器iterator遍历
        Iterator iter = set.iterator();  //新建迭代器对象
        while(iter.hasNext()){ 
              //如果迭代器中有下一个
            System.out.println(iter.next());
        }
        System.out.println("=============================");
		// 2.用增强for来遍历
        for (Object obj : set) { 
   
            System.out.println(obj);
        }

        //获取集合中的元素个数
        System.out.println(set.size());

        //如何展现Set的不可重复性，目前集合中有abcd四个元素
        set.add("a");
        System.out.println(set);
        //集合内不会新增一个a，且元素个数依旧是4

        //集合中可以存null,且要算一个元素，size要+1
        set.add(null);
        System.out.println(set);
        System.out.println(set.size());

    }

}

Iterator接口

主要用于遍历Collection集合中的元素，Iterator对象也称作迭代器，Iterator是接口，本身并不能创建对象，如果需要Iterator对象，必须有一个被迭代的集合对象，如 Iterator iter=set.iterator（）；

HashSet集合判断两个对象相等的必要条件：

1. 两个对象通过equals（）返回true
2. 两个对象的hashCode()返回值相等

泛型简介

用于限制集合只能存放一种类型的元素

格式：
HashSet<指定类型> set = new HashSet<指定类型>( );

public class test01 { 
   
    public static void main(String[] args) { 
   
        //集合可以存任何类型的数据，不指定泛型相当于默认泛型为Object
        Set set = new HashSet();
        set.add("a");
        set.add(1);
        set.add(true);
        set.add("csdn");
        System.out.println(set);

        //指定泛型为String
        HashSet<String> setString = new HashSet<>();
        setString.add("ssdasdasd");
// setString.add(123);————————编译就会报错类型不匹配

    }

TreeSet类

TreeSet类是SortedSet接口的实现类
TreeSet可以确保集合元素处于排序状态

两种排序方法：

• 自然排序（默认），升序
• 定制排序

使用TreeSet必须保证是放入同样类型的对象，否则可能会进行类型转换异常（用泛型来限制）

import java.util.Set;
import java.util.TreeSet;
public class test02 { 
   
    public static void main(String[] args) { 
   
        Set<Integer> set= new TreeSet<Integer>();
        set.add(5);
        set.add(2);
        set.add(15);
        set.add(8);
        set.add(99);
        //默认自然排序，升序
        System.out.println(set);  //输出[2, 5, 8, 15, 99]
		 //使用迭代器指定类型遍历
        Iterator<Integer> iterator = set.iterator();
        while(iterator.hasNext()){ 
   
            System.out.println(iterator.next());
        }

    }
}

如何将自定义的类放入TreeSet，并且按照指定属性排序？

自定义的类需要实现接口Comparator（java.util），实现这个接口的时候，一定要实现它里面的抽象方法compare

package setStudy1117;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class test02 { 
   
    public static void main(String[] args) { 
   

        Person person = new Person("张三",25);
        Person person1 = new Person("李四",15);
        Person person2 = new Person("王五",55);
        Person person3 = new Person("lucy",35);
        Person person4 = new Person("caty",11);

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

        }

    }
}

//建立一个 人 类 实现比较器接口（重写compare方法）
class Person implements Comparator<Person> { 
   
    int age;
    String name;
    public Person() { 
   
    }
    public Person(String name,int age) { 
   
        this.name=name;
        this.age = age;
    }
    //重写compare方法，按照年龄升序
    @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;
    }
}

运行结果

caty: 11
李四: 15
张三: 25
lucy: 35
王五: 55

【下来了解一下comparator接口的compare（）方法，补充】

2. List——有序，可重复

ArrayList类（线程不安全）

（Vector类基本和ArrayList差不多——线程安全——但已被淘汰，此处不再展开）

• ArrayList类实现了List接口，List接口继承于Collection接口
• List集合中每一个元素都有其对应的顺序索引，默认按元素添加顺序设置元素索引（有点类似数组的下标）
• List集合中添加了一些根据索引来操作集合元素的方法

package setStudy1117;
import java.util.ArrayList;
import java.util.List;
public class test03 { 
   
    public static void main(String[] args) { 
   
        List<String> list = new ArrayList<String>();
        list.add("b");
        list.add("sadab");
        list.add("asdasdasdb");
        list.add("ssb");
        System.out.println(list);  //输出[b, sadab, asdasdasdb, ssb]

        //按照索引访问指定位置的元素
        System.out.println(list.get(2));
        //可重复性，在已有"b"的情况下还能添加"b"
        list.add("b");
        list.add("sadab");
        System.out.println(list);
        //在指定位置插入元素
        list.add(1,"f");
        System.out.println(list);

        //在指定位置插入集合
        List<String> list1 = new ArrayList<>();  //新建集合list1
        list1.add("123");
        list1.add("456");
        //在二号位置插入集合list1，插入吼list1会被打散按顺序占多个位置
        list.addAll(2,list1);
        System.out.println(list);

        //获取指定元素在集合中第一次出现的索引下标，找不到返回-1
        System.out.println(list.indexOf("aaa"));
        //获取指定元素在集合中最后一次出现的索引下标，找不到返回-1
        System.out.println(list.lastIndexOf("b"));
        
        //移除指定位置的元素
        list.remove(7);
        System.out.println(list);

        //更改指定位置的元素的值
        list.set(0,"bbbbb");
        System.out.println(list);
        
        //截取指定位置及其以后的元素形成为一个新的列表
        List<String> list2 = list.subList(3,5);
        //不包含右边界，新列表长度等于终点减去起点
        System.out.println(list2);

        //获取集合长度
        System.out.println(list.size());
    }
}

3. Map接口——具有映射关系

• key，value都可以是任何引用类型的数据（在新建对象时，键和值都应该设置泛型）
• Map中的key不允许重复，通过指定的key能找到唯一的value
• HashMap类用于实现Map接口
• HashMap不保证元素顺序

HashMap类（线程不安全）

（HashTable类基本和HashMap差不多——线程安全——已被淘汰，此处不再展开）

package setStudy1117;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Test04 { 
   
    public static void main(String[] args) { 
   
        Map<String, Integer> map = new HashMap<String, Integer>();
// HashMap对象的添加方法是put（）
        map.put("小明",1);
        map.put("小红",551);
        map.put("白马",51);
        map.put("维系",1);
        map.put("扣扣",1);
        System.out.println(map);   
        //map的输出是大括号{}，且有等号连接键值对

        //根据键获取值
        System.out.println(map.get("小红"));
        //根据键删除元素
        map.remove("小红");
        System.out.println(map);
        
        //获取长度
        System.out.println(map.size());

        //查询是否存在某个键或者某个值——contains——返回true或false
        System.out.println(map.containsKey("小明"));
        System.out.println(map.containsValue(1));

        //map集合的遍历：

//方法一
		//1.首先获取map集合中的key，形成一个新的集合
        Set<String> keys = map.keySet();
		//2.然后通过遍历key集合，每次循环，以key查询value然后输出
        for (String key : keys) { 
   
            System.out.println("key:"+key+",value:"+map.get(key));

//方法二 
		//通过map.entrySet()来遍历
		//此处这个方法返回的类型为 Set< Entry <String,Integer> >
            Set<Entry<String, Integer>> entries = map.entrySet();
            for (Entry<String, Integer> entry : entries) { 
                   System.out.println("key:"+entry.getKey()+key+",value:"+entry.getValue());;
            }
        }
    }
}

下来了解Map.entry总结到这里
别人总结的

TreeMap类

• 可根据key对集合内的元素排序——自然排序和定制排序

• 一般使用map集合不会用过于复杂的对象做key

package setStudy1117;
import java.util.Map;
import java.util.TreeMap;

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

        //TreeMap的自然排序是字典排序————可以理解为ASCII码排序
        // 数字在字母前面,大写字母在小写字母前面
        
        Map<Integer, String> map = new TreeMap<>();
        map.put(1,"a");
        map.put(2,"b");
        map.put(5,"c");
        map.put(4,"a");
        System.out.println(map);
        //一般按照key排序，此处key的泛型是Integer所以按照数字升序排序

        Map<String, String> map1 = new TreeMap<>();
        map1.put("Wangwanh","a");
        map1.put("shdjsa","b");
        map1.put("bjadksd","c");
        map1.put("asdjk","a");
        map1.put("15asdjk","a");
        System.out.println(map1);
        //此处按照字典升序排序
    }
}

Collections类

Collections类（操作集合的工具类）主要功能是对Set，List，Map等集合进行处理，比如排序，增删改查，反转，随机打乱

package setStudy1117;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test06 { 
   
    public static void main(String[] args) { 
   
        List<String> list = new ArrayList<>();
        list.add("b");
        list.add("cb");
        list.add("cab");
        list.add("cb");
        list.add("a");
        list.add("1");
        System.out.println(list);
        //反转列表元素
        Collections.reverse(list);
        System.out.println(list);
        //随机打乱
        Collections.shuffle(list);
        System.out.println(list);
        //排序
        Collections.sort(list);
        System.out.println(list);//默认按照字典升序
    }
}

sort（list）：按照字典升序

sort（List，Comparator）：
根据比较器对象的比较方法（需要重写）对List集合元素进行排序

notes：

如果要使用sort（List，Comparator），则集合里的元素比如此处是学生对象，那么学生类一定要实现比较器接口（Comparator），这样学生类才能重写compare方法。

package setStudy1117;

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

//新建学生类
class Student implements Comparator<Student>{ 
   
    int age;
    String name;

    public Student(){ 
   }
    public Student(int age,String name){ 
   
        this.age=age;
        this.name=name;
    }

//根据年龄升序排列的compare方法
    @Override
    public int compare(Student o1, Student o2) { 
   
        if(o1.age>o2.age)return 1;
        else if(o1.age<o2.age)return -1;
        else return 0;

    }

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

        Student s1 = new Student(14,"张三");
        Student s2 = new Student(12,"李四");
        Student s3 = new Student(16,"王五");
        Student s4 = new Student(18,"周周");

        List<Student> stus=new ArrayList<>();
        stus.add(s1);
        stus.add(s2);
        stus.add(s3);
        stus.add(s4);
        //遍历输出集合中的数据
        for (Student student : stus) { 
   
            System.out.println(student.name+":"+student.age);
		}
		System.out.println("========================");
        //用Collections来排序———在原集合上排序
        
        Collections.sort(stus,new Student());
        for (Student student : stus) { 
   
            System.out.println(student.name+":"+student.age);
        }
    }
}


}

第一：【下来了解一下Comparator.compare（）】
第二：Collections.sort(stus,new Student());查一下这个方法，对参数进行理解

swap（List，int，int）
将指定list集合中的第i元素，和第j个元素进行交换

Collections.swap(list,0,4);

Object max（Collection）
根据元素的自然顺序，返回给定集合中的最大元素（当然也可返回最小值，max->min）

Collections.max(list);

Object max（Collection , Comparator）：
根据比较器Comparator的方法compare（）返回给定集合中的最大元素（或最小min）

package setStudy1117;

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

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

        Student s1 = new Student(14,"张三");
        Student s2 = new Student(12,"李四");
        Student s3 = new Student(16,"王五");
        Student s4 = new Student(18,"周周");

        List<Student> stus=new ArrayList<>();
        stus.add(s1);
        stus.add(s2);
        stus.add(s3);
        stus.add(s4);
        for (Student student : stus) { 
   
            System.out.println(student.name+":"+student.age);
        }

        Student stu = Collections.max(stus, new Student());
        System.out.println("集合中按照年龄来看最大项是：\n"+stu.name+":"+stu.age);
    }
}

class Student implements Comparator<Student>{ 
   
    int age;
    String name;

    public Student(){ 
   }
    public Student(int age,String name){ 
   
        this.age=age;
        this.name=name;
    }
//根据年龄升序排列
    @Override
    public int compare(Student o1, Student o2) { 
   
        if(o1.age>o2.age)return 1;
        else if(o1.age<o2.age)return -1;
        else return 0;

    }
}

输出结果：

张三:14
李四:12
王五:16
周周:18
集合中按照年龄来看最大项是：
周周:18

int frequency（Collection，Object）：
返回指定集合中指定元素的出现次数

System.out.println(Collection.frequency(list,"a"));

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

Collections.replaceAll(list,"a","aa")  //把原来集合中的全部a，替换为aa