Java学习笔记——day12 Set集合、Map集合

最新推荐文章于 2024-07-27 14:51:01 发布
最新推荐文章于 2024-07-27 14:51:01 发布
阅读量191 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S_numb/article/details/102993147
版权

Set集合:

  • 特点：

    • 不包含重复元素的集合；
    • 没有带索引的方法，所以不能使用普通for循环遍历，可以使用迭代器和增强for循环；

  • example

    import java.util.HashSet;
import java.util.Set;


public class SetDemo {
    public static void main(String[] args) {
            //创建集合对象
             //set是一个接口，不能直接实例化，需要找其实现类
            Set<String> set = new HashSet<>();

            //添加元素
            set.add("Hello");
            set.add("world");
            set.add("Java");
            //不包含重复元素
            set.add("Java");
            //遍历：迭代器或增强for
            for(String s: set){
                System.out.println(s); //HashSet对集合的迭代顺序不作任何保证
            }
    }
}

Hash值：

  • 哈希值：是jdk根据对象的地址或字符串或者数字算出来的int类型的数字

  • 哈希值不是地址；

  • 哈希值是int类型的数值；

注：Object类中有一个方法可以获得对象的哈希值，public int hashCode()

  • example

    public class HashDemo {
    public static void main(String[] args) {
            //创建学生对象
        Student s1 = new Student("张三", 23);
       //同一个对象多次调用hashCode方法，返回的哈希值是相同的
        System.out.println(s1.hashCode()); //1163157884
        System.out.println(s1.hashCode());//1163157884
        System.out.println("-----------------");
        Student s2 = new Student("张三", 23);

        //默认情况下(使用Object类)，不同对象的哈希值是不同的
        //通过方法重写是可以实现不同对象的哈希值是相同的
        System.out.println(s2.hashCode()); //1956725890

        System.out.println("重地".hashCode());
        System.out.println("通话".hashCode());
    }
}

    public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

HashSet集合

  • 特点：

    • 底层数据结构是哈希表；
    • 不保证存储和取出的元素顺一致；
    • 不能用普通for循环，是因为没有带索引的方法；
    • 由于是set集合，所以是不包含重复元素的集合；

  • example

    /*需求：
1.创建一个存储学生对象的集合，存储三个学生对象，实用程序实现控制台遍历该集合；
2.要求：学生对象的的成员变量值相同，我们就认为是同一个对象；
思路：
1.定义学生类；
2.创建HashSet集合对象；
3.创建学生对象；
4.把学生添加到集合；
5.遍历集合（增强for）
6.在学生类中重写equals和hashCode
*/
public class HashSetDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<Student> hs = new HashSet<>();
        //创建学生对象
        //Student student = new Student();
        hs.add(new Student("张三", 23));
        hs.add(new Student("李四", 24));
        hs.add(new Student("王五", 25));
        //不将equals和hashCode重写将不会去除重复元素；
        //重写是在Student类中自动生成重写方法
        hs.add(new Student("王五", 25));

        for (Student h : hs) {
            System.out.println(h.getName()+"    "+h.getAge());
        }
    }
}

    public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
	//alt+insert 系统自动重写
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
	//alt+insert 系统自动重写
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

  • HashSet集合保证元素的唯一性：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-21tmbYi5-1573311894883)(H:\2019Java-西开\笔记\HashSet元素唯一的原因.jpg)]

LinkedHashSet集合

  • 特点：

    • 哈希表和链表实现的set接口，具有可预测的迭代次序；
    • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的；
    • 由哈希表保证元素的唯一性；

  • example:

    import java.util.LinkedHashSet;
public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();

        //添加元素
        linkedHashSet.add("Hello");
        linkedHashSet.add("World");
        linkedHashSet.add("Java");

        //遍历集合
        for (String s : linkedHashSet) {
            System.out.println(s);
        }
    }
}

TreeSet集合

  • 特点：

    • 元素有序，这里的顺序不是指存储和取出的有序，而是按照一定的规则进行排序，具体方式取决于构造方法；
      • TreeSet()； 无参构造方法根据其元素的自然排序进行排序，比如26字母顺序，0-9大小顺序等；
      • TreeSet(Comparator comparator);有参构造方法根据经指定的比较器进行排序；
    • 不能使用for循环遍历；
    • 不包含重复的元素；

  • example：

    • import java.util.TreeSet;
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<>();

        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        //遍历元素
        for (Integer t : ts) {
            System.out.println(t);
        }
    }
}

    • 无参构造：Comparable

      /*存储学生对象并遍历，创建集合使用无参构造方法；
要求：按照年龄从小到大排序，年龄相同，按照 姓名的字母顺序排序*/

import java.util.TreeSet;
public class TreeSet_Comparable {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>();

        //创建学生对象：
        Student s1 = new Student("zhangsan", 13);
        Student s2 = new Student("lisi", 12);
        Student s3 = new Student("wangwu", 19);

        Student s4 = new Student("laoliu", 13);
        //添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        //遍历
        for (Student t : ts) {
            System.out.println(t.getName() + "," + t.getAge());
        }
    }
}

      public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }


    @Override
    public int compareTo(Student s) {
        /*        return 0; //表示输入元素重复
        return 1; //输入正序排列
        return -1; //输入逆序排列*/
        //按照年龄从小到大排序，
        //自然排序：this代表 s1  s代表s2
        int num = this.age - s.age;
        //年龄相同，按照 姓名的字母顺序排序
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }
}

    • 有参构造：Comparator

      /*存储学生对象并遍历，创建TreeSet集合使用带参构造方法；
要求：按照年龄从小到大排序，年龄相同，按照 姓名的字母顺序排序*/

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSet_Comparator {
    public static void main(String[] args) {
        //创建结合对象
        //需要一个Comparator接口，使用匿名内部类
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //自然排序法：
                //this.age - s.age
                //s1 s2
                //此处的this代替的是TreeSet_Comparator
                //因为Student里边的age name均是私有，故而只能调用方法来获取
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        //创建学生对象：
        Student s1 = new Student("zhangsan", 13);
        Student s2 = new Student("lis", 14);
        Student s3 = new Student("wangwu", 11);
        Student s4 = new Student("woai", 11);

        //添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        //遍历：
        for (Student t : ts) {
            System.out.println(t.getName() + "," + t.getAge());
        }

    }
}

Map集合

  • Interface Map<K,V> K：键的类型； V：值的类型

  • 将映射到值的对象：不能包含重复的键；每个键最多有一个对应的值；

  • 创建Map集合的对象：多态实现方式(具体实现类：HashMap)

  • example：

    /*
举例：学生的学号和姓名：
Student001  张三
Student002  李四
Student003  王五
*/
public class MapDemo {
    public static void main(String[] args) {
        //创建结合对象
        Map<String, String> map = new HashMap<>();

        //添加元素
        // V put(K key, V value)将指定的值与该映射中的指定键相关联
        map.put("stu001", "张三");
        map.put("stu002", "李四");
        map.put("stu003", "王五");
        //当键重复的时候，后边的值会替换前边的值，输出的时候，刘能会替换王五
        map.put("stu003", "刘能");
        //输出集合对象，HashMap重写了toString
        System.out.println(map);
    }
}

  • 常用方法：

    //创建集合对象
Map<String, String> map = new HashMap<>();

方法1.V put(K key, V value); 添加元素
    map.put("刘能", "牛");
    map.put("赵四", "鼠");
    map.put("顺子", "虎");  

方法2.V remove(Object key); 根据键删除键值对应的元素
    System.out.println(map.remove("刘能"));
    System.out.println(map.remove("刘u"));//没有该键返回null

方法3.void clear(); 移除所有的键值对应的元素
    map.clear();

方法4.boolean containsKey(Object key); 判断集合是否包含指定的键
    System.out.println(map.containsKey("赵四"));

方法5.boolean containsValue(Object value); 判断集合是否包含指定的值
    System.out.println(map.containsValue("鼠"));

方法6.int size(); 集合的长度，也就是集合中键值得个数
    System.out.println(map.size());

方法7.V get(Object key); 根据键获取值的方法
    System.out.println(map.get("刘能"));
    System.out.println(map.get("刘9"));//键不存在，返回值为null

方法8.Set<K> KeySet();   获取所有键的集合
    Set<String> keySet = map.keySet();
        for (String s : keySet) {
            System.out.println(s);
        }

方法9.Collection<V> values(); 获取所有值的集合
    Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }

方法 10.set<Map.Entry<K,V>> entrySet() 获取所有键值对 对象的集合    
     	getKey(); 得到键    
      	getValue();得到值
            for (Map.Entry<String, String> m : map) {
            String key = m.getKey();
            Student value = m.getValue();
            System.out.println(key + "-------" + value);
        }

  • Map集合遍历方法：

    /*
Map集合遍历（方式1）：
1.获取所有键的集合，用keySet()方法；
2.遍历键的集合，获取到每一个键，增强for循环；
3.根据键取找值，用get(Object key);方法
*/

/*
Map集合遍历（方式2）：
1.获取所有键值对对象的集合
    Set<Map.entry<K,V>> entrySet(); 获取所有键值对对象集合
2.遍历键值对对象的集合，得到键值对对象；
    用增强for循环，得到每一个Map.entry
3.根据键值对对象获取键和值；
    用getKey();方法获取键
    用getValue();方法获取值；
*/

import javafx.scene.control.cell.MapValueFactory;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapCollectionTraversal {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();

        //添加元素：
        map.put("刘能", "牛");
        map.put("赵四", "鼠");
        map.put("顺子", "虎");

       //方式1：
       //1.获取所有键的集合，用keySet()方法
        Set<String> keySet = map.keySet();

        //2.遍历键的集合，获取到每一个键，增强for循环；
        for (String key : keySet) {
            //3.根据键取找值，用get(Object key);方法
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
        
        //方式2：
        //1.获取所有键值对对象的集合 Set<Map.entry<K,V>> entrySet();
        Set<Map.Entry<String, String>> keyValue = map.entrySet();

        //2.遍历键值对对象的集合，得到键值对对象；用增强for循环，得到每一个Map.entry
        for (Map.Entry<String, String> MapEntry : keyValue) {
            //3.根据键值对对象获取键和值；
            //    用getKey();方法获取键
            //    用getValue();方法获取值；
            String key = MapEntry.getKey();
            String value = MapEntry.getValue();
            System.out.println(key + "," + value);
        }
    }
}

HashMap集合

  • example 1:

    /*
需求：创建一个HashMap集合，键是学号(String)，值是学生对象(Student)。
存储三个元素，并遍历；

思路：
1.定义学生类；
2.创建HashMap集合对象；
3.创建学生对象；
4.能把学生添加到集合；
5.遍历集合：
    方式1：键找值；
    方式2：键值对对象找键和值；
*/

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

public class HashMapExample {
    public static void main(String[] args) {
        //创建集合对象
        HashMap<String, Student> map = new HashMap<>();

        //创建学生对象
        Student s1 = new Student("刘能", 34);
        Student s2 = new Student("赵四", 35);
        Student s3 = new Student("玉田", 33);

        //把学生添加到集合
        map.put("001", s1);
        map.put("002", s2);
        map.put("003", s3);

        //遍历集合：
        //方式1：键找值；
        //1.获取所有键的集合keySet
        Set<String> keySet = map.keySet();
        //2.用增强for循环遍历键集合，得到每一个键
        for (String key : keySet) {
            //3.根据键取值get();
            Student value = map.get(key);
            System.out.println(key + "-------" + value.getName() + "," + value.getAge());
        }

        System.out.println("==============分界线===============");
        //方式2：键值对对象找键和值；
        // 1.Set<Map.entry<K,V>> entrySet(); 获取所有键值对对象集合
        Set<Map.Entry<String, Student>> MapEntry = map.entrySet();
        //2.用增强for循环，得到每一个Map.entry
        for (Map.Entry<String, Student> entry : MapEntry) {
            // 3.   用getKey();方法获取键
            //    用getValue();方法获取值；
            String key = entry.getKey();
            Student value = entry.getValue();
            System.out.println(key + "-------" + value.getName() + "," + value.getAge());
        }
    }
}

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

  • example 2

    /*
需求：创建一个HashMap集合，键是学生对象(Student),值是居住地(String).
存储多个键值对元素，并遍历
思路:
1.定义学生类；
2.使用HashMap集合对象；
3.创建学生对象；
4.把学生添加到集合；
5.遍历集合；
6.在学生类重写两个方法：
hashCode()   equals()  自动生成
*/

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

public class HashMapExample2 {
    public static void main(String[] args) {
        //使用HashMap集合对象；
        HashMap<Student, String> hashMap = new HashMap<>();

        //创建学生对象；
        Student s1 = new Student("赵1", 23);
        Student s2 = new Student("赵2", 22);
        Student s3 = new Student("赵3", 24);
        Student s4 = new Student("赵4", 25);
        Student s5 = new Student("赵5", 26);
        Student s6 = new Student("赵6", 21);
        Student s7 = new Student("赵6", 21);

        //把学生添加到集合；
        hashMap.put(s1, "陕西");
        hashMap.put(s2, "河南");
        hashMap.put(s3, "山东");
        hashMap.put(s4, "山西");
        hashMap.put(s5, "云南");
        hashMap.put(s6, "西藏");
        hashMap.put(s7, "西藏");

        //遍历集合；
        //方式1：
        //获取所有键keySet
        Set<Student> keySet = hashMap.keySet();
        //遍历，取出所有键 增强for
        for (Student key : keySet) {
            //根据键查找值 get()
            String value = hashMap.get(key);
            System.out.println(key.getName() + "---" + key.getAge() + "---" + value);
        }
        System.out.println("============分界线===========");
        //方式2：
        //获取键值对对象集合：
        Set<Map.Entry<Student, String>> entrySet = hashMap.entrySet();
        //遍历集合，获得每一个键值对
        for (Map.Entry<Student, String> entry : entrySet) {
            //获取键：getKey()
            //获取值：getValue();
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key.getName() + "---" + key.getAge() + "---" + value);
        }
    }
}

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

  • HashMap集合里边含有ArrayList集合

    /*
需求：创建一个HashMap集合，存储三个键值对元素，每个键值对元素的键是
String，值是ArrayList，每个ArrayList的元素是String。并遍历
思路：
1.创建Hashmap集合；
2.创建ArrayList集合，并添加元素；
3.把ArrayList作为元素添加到HashMap集合；
4.遍历HashMap集合；
数据：
第一个ArrayList集合的元素：（三国演义）、周公瑾 小乔
第二个ArrayList集合的元素：（西游记）、牛魔王 铁扇公主
第三个ArrayList集合的元素：（红楼梦）、贾宝玉 林黛玉
*/

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class HashMapIncludeArrayList {
    public static void main(String[] args) {
        //创建Hashmap集合；
        HashMap<String, ArrayList<String>> hashMap = new HashMap<>();
        //创建ArrayList集合，并添加元素
        ArrayList<String> arrayList1 = new ArrayList<>();
        arrayList1.add("周公瑾");
        arrayList1.add("小乔");

        //创建ArrayList集合，并添加元素
        ArrayList<String> arrayList2 = new ArrayList<>();
        arrayList2.add("牛魔王");
        arrayList2.add("铁扇公主");
        //创建ArrayList集合，并添加元素
        ArrayList<String> arrayList3 = new ArrayList<>();
        arrayList3.add("贾宝玉");
        arrayList3.add("林黛玉");
        //把ArrayList作为元素添加到HashMap集合
        hashMap.put("三国演义", arrayList1);
        hashMap.put("西游记", arrayList2);
        hashMap.put("红楼梦", arrayList3);

        //遍历HashMap集合
        Set<String> keySet = hashMap.keySet();
        for (String key : keySet) {
            System.out.println(key);
            ArrayList<String> valueArray = hashMap.get(key);
            for (String value : valueArray) {
                System.out.println("\t"+value);
            }
        }
    }
}

  • ArrayList集合元素为HashMap

    /*
需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap，每个
HashMap的键和值都是String，并遍历；

思路：
1.创建ArrayList集合；
2.创建HashMap集合，并添加元素；
3.把HashMap作为元素添加到ArrayList集合；
4.遍历ArrayList集合；
*/

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class ArrayListIncludeHashMap {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList<HashMap<String, String>> arrayList = new ArrayList<>();
        //创建HashMap集合，并添加元素
        HashMap<String, String> hm1 = new HashMap<>();
        //添加元素到HashMap集合
        hm1.put("赵1", "1号");
        hm1.put("赵2", "2号");
        //把HashMap作为元素添加到ArrayList；
        arrayList.add(hm1);

        HashMap<String, String> hm2 = new HashMap<>();
        //添加元素到HashMap集合
        hm2.put("李1", "3号");
        hm2.put("李2", "4号");
        //把HashMap作为元素添加到ArrayList；
        arrayList.add(hm2);

        HashMap<String, String> hm3 = new HashMap<>();
        //添加元素到HashMap集合
        hm3.put("周1", "5号");
        hm3.put("周2", "6号");
        //把HashMap作为元素添加到ArrayList；
        arrayList.add(hm3);

        //遍历ArrayList集合
        for (HashMap<String, String> hm : arrayList) {
            Set<String> keySet = hm.keySet();
            for (String key : keySet) {
                String value = hm.get(key);
                System.out.println(key + "---" + value);
            }
        }

    }
}
S_numb
关注
专栏目录
Java学习笔记——Collection之Set
D77的博客
07-28 1049
Set接口常用的实现类有HashSet、LinkedHashSet、TreeSet。Set无序不可重复的集合，只能根据元素本身来访问。
Java学习笔记——Set接口和Map接口
冷漠的小猿
08-14 4774
Set接口和Map接口 1.了解Set集合的特点 2.掌握Set集合下常用实现类的使用 3.了解Map集合的特点 4.掌握Map集合下常用实现类的使用 5.掌握Map集合的遍历方式 6.掌握Collections工具类 第一节 Set接口 1.1 Set接口常用方法 方法名 描述 ...
java 学习笔记 day12 set\map集合
KKT
11-13 189
java 学习笔记 day12 set\map集合1.set集合1.1 保证唯一性的原理2.Map集合3. 练习：HashMap嵌套ArrayList 1.set集合 1.1 保证唯一性的原理 HashSet保证元素唯一性的原理? 通过查看add方法的源码，我们知道了添加功能的执行过程中，是进行了数据的判断的。 这个判断的流程是： 首先比较对象的哈希值是否相同，这个哈希值是根据对象的hashCode()计算出来的。 如果哈希值不同，就直接添加到集合中 如果哈希值相同，继续执行equals()进行
Java学习笔记——集合
D77的博客
08-01 922
Java 集合框架主要包括两种类型的容器： 集合（Collection）—— 存储一个元素集合； 图（Map）—— 存储键/值对映射；
Day16Java学习笔记——set集合
u013583756的博客
11-14 151
SET集合 为一个子接口 List：元素有序，允许重复元素 set：元素唯一不重复 向下有HashSet、LinkedHashSet、TreeSet HashSet:顶层数据结构是哈希表（数组+链表 —JDK1.7 数组+链表+二叉树—JDK1.8） HashSet 元素为一，且无序（存取顺序不一致） HashSet集合 底层用HashMap来存的 HashSet底层数据结构式哈希表，元...
Java学习笔记——Java集合
XiaoLin
01-02 809
文章目录一、数据结构1.1、线性结构1.1.1、数组1.1.2、链表1.1.3、队列1.1.4、栈1.2、非线性结构1.2.1、哈希表1.2.2、树和二叉树1.2.2.1、树1.2.2.2、二叉树1.2.2.3、排序二叉树1.2.2.4、平衡二叉树1.2.2.4.1、左旋1.2.2.4.2、右旋1.2.2.4.3、左左1.2.2.4.4、左右1.2.2.4.5、右左1.2.2.4.6、右右1.2.2.5、红黑树二、Collection集合2.1、集合框架概述2.2、集合的分类三、List接口3.1、List
Java学习笔记-Day24 Java Set集合
qq_42141141的博客
11-05 389
Java学习笔记-Day24 Java Map集合一、Map集合1、HashMap集合1.1、构造方法1.2、常用方法1.3、遍历的方法     一、Map集合   Map是由一系列键值对组成的集合，提供了key到Value的映射。Map接口没有继承Collection接口。 在Map中一个key只能对应一个value。key不能重复，如果key重复的话，会被后面添加进来的键值对覆盖，而value值是可以重复的。 某些映射实现可明确保证其顺序，如 TreeMap 类。另一些映射实现则不保证顺序，如 Hash
Java学习笔记-Day25 Java Map集合
qq_42141141的博客
11-06 509
Java学习笔记-Day25 Java Map集合一、Map集合1、HashMap集合1.1、构造方法1.2、常用方法1.3、遍历的方法2、TreeMap集合     一、Map集合   Map是由一系列键值对组成的集合，提供了key到Value的映射。Map接口没有继承Collection接口。 在Map中一个key只能对应一个value。key不能重复，如果key重复的话，会被后面添加进来的键值对覆盖，而value值是可以重复的。 某些映射实现可明确保证其顺序，如 TreeMap 类。另一些映射实现则不
java学习笔记markdown
12-22
Java学习笔记Markdown版包含了多个章节，涵盖了Java编程的多个核心概念。这些笔记是学习Java时进行知识总结的理想资源，尤其适合初学者或正在巩固基础知识的开发者。以下是对这些笔记内容的详细解读： 1. **继承** ...
博学谷：Java基础知识精讲学习笔记——DAY2
qq_46000312的博客
12-31 442
1. Date类 ​ 日期和日历类，用于操作日期相关信息。 ​ 构造方法 Date() : 构造一个日期对象，当前系统时间，精确到毫秒。 package cn.itcast.dateandcalendardemo; import java.util.Date; public class Test { public static void main(String[] args) { //测试Date类 //测试空参构造，采用的是当前系统的默认时间。
Java学习笔记——流操作
冷漠的小猿
09-02 321
缓冲流 作用：主要是为了增强基础流的功能而存在的，提高了流的工作效率【读写效率】 注意：如果使用记事本创建的文件，文件是utf-8或者unicode编码，文件的前面有一个BOM（Byte Order Mark）头,BOM作用指定文件使用的编码类型。GBK编码没有添加bom头。 utf-8:EF BB BF unicode 小端: FF FE 66 00 unicode 大端 ：FE ...
学习笔记——day47(jsp)
Katherine_c的博客
09-10 160
一、基础语法 1.1 注释 ① 显示注释语法：从 HTML 风格继承而来 ② 隐式注释语法：从 JAVA 风格继承；JSP 自己的注释 JSP 的三种注释方式：   1）// 注释，单行注释 /* 多行注释 */   2）   3）<%-- JSP 注释 --%> 1.2 Scriptlet 第一种：<% %> ：java 脚本段，可以定义局部变量、编写语句 第二种：&lt...
如何判断应该设计类、子类、抽象类或接口？
最新发布
S_numb的博客
07-27 799
来源：《Head First Java》第二版：227 页。
JavaScript - BOM
S_numb的博客
01-09 709
这篇文章参考内容分为两部分： 西部开源-秦疆老师； https://www.w3school.com.cn/h.asp； 文章目录BOM1.1 JS Window1.2 JS Screen1.3 JS Location1.4 JS History1.5 JS Navigator1.6 JS 弹出框1.7 JS Timing1.8 JS Cookies BOM JavaScript Wi...
Day22——HTML
S_numb的博客
12-17 653
文章目录HTML一、 关于 html 那些事1. 为什么要学 html？2. 什么是 html？3. 发展史4. 优势5. W3C 标准6. 学习 html 要达到的方法和目标7. 第一个 HTML 案例二、HTML 的基础知识1. HTML 的基本结构1.1 HTML 头部元素1.1.1 title 标签1.1.2 base 标签1.1.3 Link 标签1.1.4 style 标签1.1.5 ...
MySQL
S_numb的博客
01-29 650
文章目录1. 操作数据库1.1 创建数据库1.2 查看数据库1.3 修改数据库1.4 删除数据库1.5 使用数据库2. MySQL 存储引擎2.1 什么是存储引擎2.2 MySQL 5.7 支持的存储引擎2.3 如何选择 MySQL 存储引擎3. MySQL 常见数据类型3.1 整数类型3.2 小数类型3.3 日期/时间类型3.4 字符串类型4. 数据库的字段属性5.操作数据库表5.1 创建数据库...
MySQL - 初识及安装
S_numb的博客
01-12 648
这篇文章参考内容分为两部分： 西部开源-秦疆老师； http://c.biancheng.net/view/2413.html； 文章目录MySQL1. 初始 MySQL1.1 MySQL 是什么？1.2 数据存储方式1.3 什么是数据库1.4 数据可的存储结构1.5 数据库在开发中的作用1.6 数据库系统1.7 了解 SQL 语言1.8 数据库访问技术1.9 MySQL 的优势1.10 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值