欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-07-11 09:14:34
Set集合 哈希值 Set集合存储元素不重复的原理 Set集合在调用add方法的时候,add方法会调用元素的hashCode方法和equals方法,判断元素是否重复,若hashCode和equals都相同则不添加到集合,要保证hashCode和equals不同必须重写hashCode和equals方 ......

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