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

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流相结合的集合