ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

java学习笔记017

2021-06-18 20:30:53  阅读:134  来源: 互联网

标签:java String gender System 笔记 017 new public out


一.Set 接口

1.基本概念

Set : 是 Collection 的子接口, 特点是无序不可重复(自动去重),

新增方法: Set< E > of(E... elements)返回包含任意数量元素的不可修改集合。 无序: 存放的顺序与内部真实存储的顺序不一致(内部有自己存储的规则). 去重: 两个数据调用equals方法返回值true,相同需要去重,false不同可以添加.

遍历方式只有两种 :1.for each 2.迭代器 iterator

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
​
public class Set {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(123);//自动去重只能存进去一个
        set.add(123);
        System.out.println(set);//[123]
​
        Set<String> set2 = new HashSet<>();
        set2.add("哈哈");
        set2.add("ab");
        set2.add("呵呵");
        set2.add("bd");
        set2.add("a");
        set2.add("吼吼");
        System.out.println(set2);//[ab, a, bd, 哈哈, 呵呵, 吼吼]真实的存储顺序与实际存入顺序不同, 按照集合内部自己的排序方式.
        //for each遍历
        int i= 1;
        for (Object obj:set2) {
            if(i==set2.size()){
                System.out.print(obj);
                break;
            }
            System.out.print(obj+"   ");
            i++;
        }
        //迭代器遍历
        Iterator it = set2.iterator();
        while (it.hasNext()){
            System.out.print(it.next()+"   ");
        }
​
        //static <E> Set<E> of(E... elements) 返回包含任意数量元素的不可修改集。
        Set<Integer> set3 = Set.of(1,2,3,4,5);
    }
}

2.HashSet实现类

HashSet : Set 接口的实现类.无新增功能,无序不可重复. 底层结构: 哈希表 (数组+链表+红黑树) ->是由HashMap维护. 优点 : 查询,增删效率较高. 应用场景: 实现不存储相同数据,查询,增删效率较高的时候建议使用HashSet

哈希表 : 数组+链表+红黑树

存储数据的步骤:

  1. 数据首先传给 hashcode ( ) 方法, hashcode 方法默认根据对象的地址通过hash指定的算法计算后返回一个int类型的整数.

  2. 得到返回的int整数后,通过指定的hash算法计算数据要存在数组的哪个索引位置,不同的jdk版本哈希算法不尽相同,一般会尽量分散在数组的每个索引位置.

  3. 确定索引位置后,如果在指定的索引位置中没有链表及节点存在,直接把这个数据作为链表头存入这个索引位置, 如果已经有链表存在, 就需要遍历这个链表的每一个节点,调用 equals 方法比较这个数据与链表中的节点数据是否相等,如果每一个都不相等就把这个数据存入这个链表的最后.

  4. 当链表长度>8并且数组的总长度>64的时候,会把链表变为红黑树.

注意: 前提是重写hashcode与equals方法,让它根据成员变量值去计算而不是对象地址.equals相等,hashcode的结果一定相等; hashcode结果一样, equals 不一定相等.

import java.util.HashSet;
import java.util.Objects;
​
public class HashSet {
    public static void main(String[] args) {
        HashSet<Person> hash = new HashSet();
        hash.add(new Person("天一","男",18));
        hash.add(new Person("天二","男",23));
        hash.add(new Person("天三","男",19));
        hash.add(new Person("天四","男",24));
        hash.add(new Person("天五","男",25));
        hash.add(new Person("天五","男",25));
        //两个天五只能存进去一个
        for (Person p:hash) {
            System.out.println(p);
        }
    }
}
//自定义类引用数据类型
class Person{
    private String name;
    private String gender;
    private int age ;
​
    public Person() {
    }
​
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getGender() {
        return gender;
    }
​
    public void setGender(String gender) {
        this.gender = gender;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }
​
    @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) &&
                Objects.equals(gender, person.gender);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, gender, age);
    }
}

3. TreeSet 实现类

TreeSet : Set接口的实现类,无序不可重复.

3.1基本定义

底层结构: 红黑树(平衡二叉树). 特点: 自动做生序排序. 新增功能: 新增了一些能够比较的相关功能.

public class TreeSet {
    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>();
        set.add(5);
        set.add(2);
        set.add(1);
        set.add(3);
        set.add(4);
        System.out.println(set);[1,2,3,4,5]
​
        //E ceiling(E e) 返回此set中大于或等于给定元素的 null元素,如果没有这样的元素,则 null 。
        System.out.println(set.ceiling(6));//没有大于6的,null
​
        //E first() 返回此集合中当前的第一个(最低)元素。
        System.out.println(set.first());
        //E last() 返回此集合中当前的最后一个(最高)元素。
        System.out.println(set.last());
​
        //E higher(E e) 返回此集合中的最小元素严格大于给定元素,如果没有这样的元素,则 null 。
        System.out.println(set.higher(1));//从第一个开始比较拿出第一个比1大的值.
​
        //E pollFirst() 检索并删除第一个(最低)元素,如果此组为空,则返回 null 。
        //E pollLast() 检索并删除最后一个(最高)元素,如果此集合为空,则返回 null 。
        System.out.println(set.pollFirst());//删除第一个数
        System.out.println(set.pollLast);//删除最后一个数
    }
}

3.2 比较器(比较规则)

在 TreeSet 存储自定义引用数据类型的数据时, 存储对象的排序与去重都需要指定比较规则.

按编写位置分为:内部比较器和外部比较器.在没有指明使用外部比较器(定制排序)的情况下,默认使用内部比较器(自然排序).

  1. 内部比较器 | 自然排序 :定义在需要存储的引用数据类型的类内部的一个指定的比较方式(方法).缺点是代码固定不够灵活.

    步骤:1)让引用数据类型的类实现 Comparable 接口, 2)重写 Comparable 的 compareTo ( T o )方法,返回值为 int 类型. T1.compare( T2 ) .比较两个数据的大小, 当返回值为 0 时->T1 = T2 , 返回正数时-> T1 > T2 .返回负数时-> T1 < T2 .

  1. 外部比较器 | 定制排序 : 定义在要存储的引用数据类型的类外部的一个指定的比较规则(方法).

    步骤:1)让引用数据类型的类实现 Comparator 接口, 重写 compare ( T t1, T t2)方法返回值为 int 类型. t1.compare( t2 ) .比较两个数据的大小, 当返回值为 0 时->t1 = t2 , 返回正数时-> t1 > t2 .返回负数时-> t1 < t2 .

import java.util.Arrays;
import java.util.Comparator;
​
public class TreeSet {
    public static void main(String[] args) {
        //指明外部比较器
        //com 可简化为lambda表达式 (x,y)->x.getAge()-y.getAge()
        TreeSet<User> treeSet = new TreeSet<>(com);
        treeSet.add(new User("孙悟空","男",9999));
        treeSet.add(new User("盖伦","男",30));
        treeSet.add(new User("彦","女",6500));
        treeSet.add(new User("赵信","男",32));
        treeSet.add(new User("炙心","女",4300));
        treeSet.add(new User("卡尔","男",9999));
        //匿名内部类
        Comparator<User> com = new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                if(o1.getGender().compareTo(o2.getGender())==0){
                    return o1.getAge()-o2.getAge();
                }
                return o1.getGender().compareTo(o2.getGender());
            }
        };
         
        for (User u:users) {
            System.out.println(u);
        }
    }
}
//数据类型的类实现Comparable接口,<User>表示只能比较这个类型的对象数据
public class User implements Comparable<User>{
​
        private String name;
        private String gender;
        private int age ;
​
        public User() {
        }
​
        public User(String name, String gender, int age) {
            this.name = name;
            this.gender = gender;
            this.age = age;
        }
​
        public String getName() {
            return name;
        }
​
        public void setName(String name) {
            this.name = name;
        }
​
        public String getGender() {
            return gender;
        }
​
        public void setGender(String gender) {
            this.gender = gender;
        }
​
        public int getAge() {
            return age;
        }
​
        public void setAge(int age) {
            this.age = age;
        }
​
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", gender='" + gender + '\'' +
                    ", age=" + age +
                    '}';
        }
​
​
         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
             if (o == null || getClass() != o.getClass()) return false;
             User user = (User) o;
             return age == user.age &&
                     Objects.equals(name, user.name) &&
                     Objects.equals(gender, user.gender);
         }
​
         @Override
         public int hashCode() {
             return Objects.hash(name, gender, age);
         }
        //重写compareTo(T o)方法.内部比较器
        @Override
        public int compareTo(User o) {
            if(this.getName().compareTo(o.getName())==0){
                if(this.getAge()-o.getAge()==0){
                    this.getGender().compareTo(o.getGender());
                }else {
                    return this.getAge()-o.getAge();
                }
            }
            return this.getName().compareTo(o.getName());
        }
}

二.Map<K,V>接口

1.基本定义

Map<K,V> : 集合中的元素由键值对k-v组成, Map的无序与去重 由key决定 k: 可以为任意引用数据类型数据 --> Set 无序不可重复 v: 可以为任意引用数据类型数据 --> Collection 可重复无序 一个key只能对应一个value->映射关系, 可以根据key操作value

import java.util.HashMap;
import java.util.Map;
public class Map {
    public static void main(String[] args) {
        //创建Map集合,key存储int类型数据,value储存String类型数据
        Map<Integer,String> map = new HashMap<>();
        //V put(K key, V value) 将指定的值与此映射中的指定键相关联。
        map.put(1001,"张三");//成对储存
        map.put(1002,"李四");
        map.put(1003,"王五");
​
        System.out.println(map.put(1002,"LISA"));//重复的key,value值会被覆盖,返回被覆盖的值
        System.out.println(map);
        //V get(Object key) 返回指定键映射到的值,如果此映射不包含键的映射,则返回 null 。
        System.out.println(map.get(1001));
​
        //boolean containsKey(Object key) 如果此映射包含指定键的映射,则返回 true 。
        //boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值,则返回 true 。
        System.out.println(map.containsKey(1003));
        System.out.println(map.containsValue("zhangsan"));
​
        //V remove(Object key) 如果存在,则从该映射中移除键的映射。
        System.out.println(map.remove(1001));
        System.out.println(map);
    }
}

2.遍历方式

1.keySet 获取所有的key值,返回一个set集合.既可以获取到key,也可以获取到value. 2.values() 获取map集合中所有键值对的value,返回一个Collection集合.只能获取到value, 3.entrySet() 获取所有的键值对->Map.Entry 类型->表示一个键值对.

import java.util.*;
​
public class Each {
    public static void main(String[] args) {
        //创建Map集合
        Map<Integer,String> map = new HashMap<>();
        map.put(1000,"天");
        map.put(1001,"地");
        map.put(1002,"人");
​
        //1.keySet
        Set<Integer> keys = map.keySet();
        for (Integer i :keys){
            System.out.println(i+"<-->"+map.get(i));
        }
        //2.values
        Collection<String> val = map.values();
        for(String s:val){
            System.out.println(s);
        }
        //3.entrySet
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        Iterator<Map.Entry<Integer,String>> it = set.iterator();
        for(;it.hasNext();){
            Map.Entry entry = it.next();
            System.out.println(entry.getKey()+"<-->"+entry.getValue());
        }
    }
}

3.HashMap实现类

底层结构: 哈希表(数组+链表+红黑树).特点: 查询,增删效率较高.

扩容问题: 初始容量16,newCap = oldCap << 1 数组每次扩容原容量的两倍 DEFAULT_INITIAL_CAPACITY 初始容量 16 DEFAULT_LOAD_FACTOR : 默认加载因子 0.75 threshold : 扩容临界值 DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY

在使用HashMap存储自定义的引用数类型的数据时, 类型中应该重写hashcode方法(作为比较规则)实现去重和value的覆盖.

import java.util.Set;
import java.util.TreeMap;
​
public class HashMap {
    public static void main(String[] args) {
        HashMap<Teachers,String> hmap = new HashMap<>();
​
        hmap.put(new Teachers("殷老师","java初级"),"5年");//被覆盖
        hmap.put(new Teachers("李老师","大数据"),"6年");
        hmap.put(new Teachers("裴老师","java高级"),"7年");
        hmap.put(new Teachers("廖老师","java中级"),"8年");
        hmap.put(new Teachers("卢老师","java鼓励师"),"9年");
        hmap.put(new Teachers("殷老师","董事长"),"2年");
        Set<Teachers> set = hmap.keySet();
        for(Teachers s:set){
            System.out.println(s+"<-->"+hmap.get(s));
        }
    }
}

4.TreeMap实现类

TreeSet底层是由TreeMap维护的,TreeMap 新增了一些有关于比较的方法. 底层结构: 红黑树. 特点: 自动做升序排序(根据key做升序)(key为自定义引用数据类型时需要比较器).

import java.util.Set;
import java.util.TreeMap;
​
public class TreeMap {
    public static void main(String[] args) {
        TreeMap<Teachers,String> tmap = new TreeMap<>((t1,t2)->t1.getName().compareTo(t2.getName()));
​
        tmap.put(new Teachers("殷老师","java初级"),"5年");
        tmap.put(new Teachers("李老师","大数据"),"6年");
        tmap.put(new Teachers("裴老师","java高级"),"7年");
        tmap.put(new Teachers("廖老师","java中级"),"8年");
        tmap.put(new Teachers("卢老师","java鼓励师"),"9年");
        tmap.put(new Teachers("殷老师","董事长"),"2年");
        Set<Teachers> set = tmap.keySet();
        for(Teachers s:set){
            System.out.println(s+"<-->"+tmap.get(s));
        }
    }
}

5.Properties 类

Properties : 存储字符串类型的键值对,特点是可以保存到流中或从流中加载。

优点 : 可以通过Properties实现软编码,从满足Properties特点的配置文件中读取数据,便于后期维护.

使用步骤: 1.定义一个(后缀名为.properties的)配置文件 xx.properties (键值对都是字符串), 在文件中保存键值对.(如: 张三=河南人) 2.创建Properties类型的对象,调用load从流中加载(输入流的数据源就是配置文件). 3.从配置文件中读取数据,加载使用.

import java.io.IOException;
import java.util.Properties;
public class Properties {
    public static void main(String[] args) throws IOException {
        Properties pro = new Properties();
​
        //void load(InputStream inStream) 从输入字节流中读取属性列表(键和元素对)。
        pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
        System.out.println(pro.getProperty("username"));//zhangsan
        System.out.println(pro.getProperty("password"));//root
    }
}
db.properties : 配置文件
    username=zhangsan
    password=root

标签:java,String,gender,System,笔记,017,new,public,out
来源: https://blog.csdn.net/weixin_58665137/article/details/118033108

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有