笔记-迎难而上之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流相结合的集合