笔记-迎难而上之Java基础进阶

Set集合

import java.util.*;
public class HashSetDemo{
    public static void main(String[] args){
    //Set接口的特点
    //是一个没有索引的集合，不允许存储重复的元素
    //HashSet继承自Set接口
    Set<String> aSet = new HashSet<String>();
    //Set接口也是继承自Collection接口，所以也继承了他的方法
    aSet.add("李白");
    aSet.add("杜甫");
    aSet.add("苏轼");
    aSet.add("辛弃疾");
    aSet.add("辛弃疾");
    System.out.println(aSet);//[辛弃疾, 李白, 杜甫, 苏轼],输出结果为无序，不可以重复这个就是HashSet集合的特点
    //没有索引，索引不能用for循环遍历
    //遍历的话，可以使用迭代器iterator,调用Collection的方法iterator，将会返回一个迭代器
    Iterator<String> iterator = aSet.iterator();
    //使用迭代器Iterator的方法hasNext,和next遍历集合
    while(iterator.hasNext()){
        String str = iterator.next();
        System.out.println(str);
    }
    System.out.println("=========================");
    //增强for循环遍历
    for(String str1 :aSet){
        
        System.out.println(str1);
    }
    }
}

哈希值

public class Person{
    
}

//哈希值：是一个十进制的整数，有系统随机给出
//是一个对象地址值，是一个逻辑地址，是模拟出来得到
//的地址，不是数据实际存储的物理地址
//在Object类中有一个方法，可以获取对象的哈希值
public class HashCodeDemo{
    public static void main(String[] args){
    Person p1 = new Person();
    //调用HashCode的方法，将会返回一个哈希值
    int hashCode = p1.hashCode();
    System.out.println(hashCode);//991505714
    
    }
}

Set集合存储元素不重复的原理

Set集合在调用add方法的时候，add方法会调用元素的hashCode方法和equals方法，判断元素是否重复，若hashCode和equals都相同则不添加到集合，要保证hashCode和equals不同必须重写hashCode和equals方法

LinkedHashSet

import java.util.*;
public class LinkedHashSetDemo{
    public static void main(String[] args){
    LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
    linkedHashSet.add("李白");
    linkedHashSet.add("苏轼");
    linkedHashSet.add("李清照");
    linkedHashSet.add("杜甫");
    linkedHashSet.add("李白");
    System.out.println(linkedHashSet);//[李白,苏轼, 李清照, 杜甫],有序，不重复

    
    } 
}

可变参数

//可变参数原理，可变参数底层就是一个数组，根据传递//参数个数不同，会创建不同的长度的数组
public class VarArgsDemo{
    public static void main(String[] args){
    int num = method(1,2,3,4,5);
    System.out.println(num);
    }
    public static int method(int...arr){
    
    int sum = 0;
    for(int i=0;i<arr.length;i++){
        sum = sum+arr[i];
    }
    return sum;
    }
}

Collections集合工具类对集合进行操作

import java.util.*;
public class CollectionsDemo{
    public static void main(String[] args){
    ArrayList<Integer> arraylist = new ArrayList<>();
    //addAll往集合中添加元素，静态方法，直接调用
    Collections.addAll(arraylist,1,2,3,4,5);
    System.out.println(arraylist);
    }
}

public class Person implements Comparable<Person>{
    private String name;
    private int age;
    
    public Person(){}
    
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    //重写toString，输出对象时会调用toStirng的方法
    public String toString(){
        String str = "name="+name+" age="+age;
        return str;
    }
    
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    //重写compareTo方法
    public int compareTo(Person o){
        //Comparable接口的排序规则，自己-参数，为升序
        return this.getAge()-o.getAge();
    }
}

import java.util.*;
//对集合进行排序
public class SortDemo{
    public static void main(String[] args){
    ArrayList<Integer> list = new ArrayList<>();
    list.add(4);
    list.add(2);
    list.add(3);
    list.add(1);
    //使用Collections的sort方法，排序
    Collections.sort(list);
    System.out.println(list);
    //怎么样对对象进行排序
    //对对象进行排序需要对象实现一个接口Comparable
    //并且重写接口中的方法compareTo定义排序的规则
    Person p1 = new Person("李白",22);
    Person p2 = new Person("杜甫",23);
    Person p3 = new Person("李清照",18);
    ArrayList<Person> list1 = new ArrayList<>();
    list1.add(p1);
    list1.add(p2);
    list1.add(p3);
    System.out.println(list1);
     //对Person按照年龄进行排序
    Collections.sort(list1);
    System.out.println(list1);//[name=李清照 age=18, name=李白 age=22, name=杜甫 age=23]
    }
}

Map集合

Map集合的提点：

1. Map集合时一个双列集合Map<k,v>

2. Map集合中的元素，key和value的数据类型可以相同，也可以不同

3. Map'集合中的元素，key时不允许重复的，value时可以重复的

4. Map集合中的元素，key和value时一一对应的

常用的Map集合的实现类

HashMap集合：

HashMap集合实现了Map接口

1. HashMap集合底层时哈希表，查询的速度特别的快
2. HashMap集合是一个无序的集合

LinkedHashMap集合

LinkedHashMap集合继承了HashMap集合

1. 查询速度快

2. 有序的集合

Map接口中的常用方法

import java.util.*;
//Map集合常用的方法
public class MapDemo{
    public static void main(String[] args){
    //使用Map集合的实现类HashMap来创建多态
    Map<String,String> aMap = new HashMap<>();
    //向集合中添加键值对的方法put
    aMap.put("周瑜","小乔");
    aMap.put("孙策","大乔");
    aMap.put("吕布","貂蝉");
    System.out.println(aMap);//吕布=貂蝉, 孙策=大乔, 周瑜=小乔}
    //Map集合中不允许存储重复的key,如果重复了话，会把后来的key的value替换原来的value
    aMap.put("吕布","西施");
    System.out.println(aMap);//吕布=西施, 孙策=大乔, 周瑜=小乔}
    
    System.out.println("=========手动分割线==========");
    //get方法，会根据指定的键，获取对应的值
    String str = aMap.get("周瑜");
    System.out.println(str);//小乔
    //containsKey();判断集合中是否包含指定的键，返回boolean
    boolean b = aMap.containsKey("吕布");
    System.out.println(b);//true
    //remove;把指定的键所对应的键值对元素，删除掉，返回被删除元素的值
    String str2 = aMap.remove("吕布");
    System.out.println(str2);//西施
    System.out.println(aMap);//{孙策=大乔, 周瑜=小乔}   
    
    }
}

Map遍历建找值

import java.util.*;
public class KeySetDemo{
    public static void main(String[] args){
    Map<String,Integer> aMap = new HashMap<>();
    aMap.put("大乔",22);
    aMap.put("小乔",20);
    aMap.put("王昭君",24);
    aMap.put("杨玉环",26);
    //遍历集合的第一种方式通过Map集合中的keySet方法获得一个包含所有key的Set集合
    Set<String> aSet =aMap.keySet();
    //获取迭代器
    Iterator<String> iterator = aSet.iterator();
    //先判断有没有下一个元素，然后获取出Key
    while(iterator.hasNext()){
    String aKey = iterator.next();
    Integer aInteger = aMap.get(aKey);
    System.out.println(aKey+"-"+aInteger);
    }
    System.out.println("手动分割线");
    //增强for第二章遍历方式
    for(String bKey:aSet){
        Integer bInteger = aMap.get(bKey);
        System.out.println(bKey+"-"+bInteger);
    }
    
    //第三种方式使用Entry对象遍历
    //实现步骤
    /*
    1.使用Map集合中的方法entrySet（），把集合中多个Entry(键值对)对象取出来，存到一个Set集合中
    2.遍历Set集合，获取每一个对象
    3.使用Entry对象中的方法getKey()和getValue()获取键与值
    */
    System.out.println("=============");
    Set<Map.Entry<String,Integer>> set = aMap.entrySet();
    //增强for
    for(Map.Entry<String,Integer> entry : set){
        String key = entry.getKey();
        Integer value = entry.getValue();
        System.out.println(key+"-"+value);
    }
    
    }
}

package demo14;

import java.util.Objects;

public class Person {
    private String name;
    private  int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package demo14;

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

public class PersonDemo {
    public static void main(String[] args) {
        show1();
    }
    private static void show1(){
        //要保证存起来的key唯一，必须重写hashCode和equals方法
        HashMap<Person,String > map = new HashMap<>();
        map.put(new Person("女王",18),"英国");
        map.put(new Person("秦始王",19),"秦国");
        map.put(new Person("普京",18),"俄罗斯");
        map.put(new Person("女王",18),"美国");
        Set<Map.Entry<Person,String >> set = map.entrySet();
        for(Map.Entry<Person,String > entry:set){
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"--"+value);
        }
    }

    private static void show() {
        HashMap<String,Person> map = new HashMap<>();
        map.put("北京",new Person("张三",18));
        map.put("上海",new Person("李四",19));
        map.put("广州",new Person("王五",20));
        map.put("北京",new Person("赵六",18));
        Set<String> set = map.keySet();
        for(String key :set){
            Person value = map.get(key);
            System.out.println(key+"--"+value);
        }
    }

}

LinkedHashMap集合

package demo14;

import java.util.HashMap;
import java.util.LinkedHashMap;

//LinkedHashMap继承自HashMap
public class LinkedHashMapDemo {
    public static void main(String[] args) {
    //是一个有序的集合
    HashMap<String,String> map  = new LinkedHashMap<>();
    map.put("a","a");
    map.put("c","c");
    map.put("d","d");
    map.put("a","b");
    System.out.println(map);//{a=b, c=c, d=d},有序，不重复
}
}

Hashtable集合

Hashtable集合继承自Map接口

Hashtable不能够存储Null键null值，现在这个集合已经被淘汰了，但是他的子类Properties集合依然活跃，是一个和IO流相结合的集合

如果有想学习java的程序员，可来我们的java学习扣qun：83078，3865，免费送java的视频教程噢！我每晚上8点还会在群内直播讲解Java知识，欢迎大家前来学习哦