Java 学习 day3

最新推荐文章于 2022-09-13 15:59:36 发布

qq_43162004

最新推荐文章于 2022-09-13 15:59:36 发布

阅读量584

点赞数

分类专栏： java学习文章标签： java

本文链接：https://blog.csdn.net/qq_43162004/article/details/123791966

版权

java学习专栏收录该内容

12 篇文章 0 订阅

订阅专栏

常用类

collection

Iterator

package com.zyj.demo_01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo {
    public static void main(String[] args) {
        // 创建Collection集合对象
        Collection<Student> c = new ArrayList<Student>();

        // 创建学生对象
        Student s1 = new Student("zmy, 30");
        Student s2 = new Student("lqx, 33");
        Student s3 = new Student("wzx, 35");

        // 把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);

        // 遍历集合（迭代器方式）
        Iterator<Student> it = c.iterator();
        while(it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());

        }
    }
}

List集合存储学生对象并遍历

package com.zyj.demo_01;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo02 {

    /*
    *需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
    思路:
    1 :定义学生类
    2:创建List集合对象3:创建学生对象
    4:把学生添加到集合
    5 :遍历集合(迭代器方式,for循环方式)
    * */

    public static void main(String[] args) {
        // 创建List集合对象
        List<Student> list = new ArrayList<Student>();

        // 创建学生对象
        Student s1 = new Student("lqx",30);
        Student s2 = new Student("zmy",33);
        Student s3 = new Student("wzx",35);

        // 把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        // 迭代器方式
        Iterator<Student> it = list.iterator();
        while(it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }

        System.out.println("--------------------------------------");

        // for循环方式
        for(int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }

    }

}

并发修改异常的源码分析

public interface List<E> {
    Iterator<E> iterator();
    boolean add(E e);

}

public abstract class AbstractList<E> {
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }


    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }



    protected int modCount = 0;
}



public class ArrayList<E> extends AbstractList<E> implements List<E> {

    public Iterator<E> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
        /*
        modCount:实际修改集合的次数
        expectedModCount：预期修改集合的次数
        */


        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }


        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
}

Set集合

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

public class SetDemo01 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();

        // 添加元素
        set.add("hello");
        set.add("world");
        set.add("java");

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

哈希表

哈希表存储：哈希表总共16个空（0~15），哈希值除以16后，余多少就存在哪个里面，先比较哈希值，然后比较内容，只要有一个不一样就存入哈希表，链表形式往下存储

HashSet集合存储学生对象并遍历

package com.zyj.demo_01;

import java.util.HashSet;

public class HashSetDemo02 {
    public static void main(String[] args) {
        // 创建HashSet集合对象
        HashSet<Student> hs = new HashSet<Student>();

        Student s1 = new Student("LQX",30);
        Student s2 = new Student("ZMY",33);
        Student s3 = new Student("WZX",35);

        /*
        * 这里重复的哈希表应该不存储它，但是不同对象的哈希值默认是不同的，
        * 所以要在student里面重写equals()和hashCode()这两个方法，
        * 保证在对象内部存储内容一致时对象的哈希值相同，从而保证hashCode元素唯一性
        *
        * */
        Student s4 = new Student("WZX",35);

        // 把学生添加到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);

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

这里重复的哈希表应该不存储它，但是不同对象的哈希值默认是不同的，所以要在student里面重写equals()和hashCode()这两个方法，保证在对象内部存储内容一致时对象的哈希值相同，从而保证hashCode元素唯一性

LinkedHashSet

1.哈希表和链表实现Set接口，具有可预测的迭代次序
2.由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
3.由哈希表保证元素唯一，也就是说没有重复的元素

LinkedHashSet<Student> hs = new LinkedHashSet<Student>();

TreeSet集合

TreeSet() 括号里面为空时自然排序

import java.util.TreeSet;

public class TreeSetDemo01 {
    public static void main(String[] args) {
        // 创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();

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

        ts.add(30); // 不包含重复的

        // 遍历集合
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}

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

package com.zyj.demo_01;

import java.util.TreeSet;

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

        // 添加元素
        Student s1 = new Student("xs",29);
        Student s2 = new Student("wzj",30);
        Student s3 = new Student("dc",28);
        Student s4 = new Student("yyh",33);

        Student s5 = new Student("lqx",33);
        Student s6 = new Student("lqx",33);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6); // 这里不会显示，因为保证唯一性


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

Student类中需要重写一下compareTo这个方法

    @Override
    public int compareTo(Student s) {
//        return 0; // 只存储第一个
//        return 1; // 升序排序
//        return -1;// 降序排序
        // 按照年龄排序,this代表下一个，s代表已存储的
        int num = this.age - s.age;
        // 当年龄相同时，按照姓名的字母顺序排序
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return  num2;
    }

比较器排序Comparator的使用：比较器排序，就是让集合构造方法接受Comparator的实现类对象，重写compara(T o1, T o2)方法

package com.zyj.demo_01;

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

public class TreeSetDemo03 {
    public static void main(String[] args) {
    	// 这里写一个内部类
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                // this.age - s.age
                //s1,s2
                int num1 = s1.getAge() - s2.getAge();
                int num2 = num1 == 0 ? s1.getName().compareTo(s2.getName()) : num1;
                return num2;
            }
        });

        Student s1 = new Student("xs",29);
        Student s2 = new Student("wzj",30);
        Student s3 = new Student("dc",28);
        Student s4 = new Student("yyh",33);

        Student s5 = new Student("lqx",33);
        Student s6 = new Student("lqx",33);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6); // 这里不会显示，因为保证唯一性


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

成绩排序

需求:用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并逸历该集合
要求：按照总分从高到低出现
思路:
1:定义学生类
2:创建TreeSet集合对象,通过比较器排序进行排序
3:创建学生对象
4:把学生对象添加到集合
5:遍历集合

package com.zyj.demo_01;

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

public class TreeSetDemo04 {
    public static void main(String[] args) {
        TreeSet<Student_2> ts = new TreeSet<Student_2>(new Comparator<Student_2>() {
            @Override
            public int compare(Student_2 s1, Student_2 s2) {
//                int num1 = (s2.getChinese() + s2.getMath()) - (s1.getChinese() + s1.getMath());
                int num1 = s2.getSum() - s1.getSum();
                int num2 = num1 == 0 ? s2.getChinese() - s1.getChinese() : num1;
                int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;
                return num3;
            }
        });

        // 创建学生对象
        Student_2 s1 = new Student_2("lqx", 98, 100);
        Student_2 s2 = new Student_2("zmy", 95, 95);
        Student_2 s3 = new Student_2("wzx", 100, 93);
        Student_2 s4 = new Student_2("ly", 100, 97);
        Student_2 s5 = new Student_2("fqy", 98, 98);
        Student_2 s6 = new Student_2("zlc", 97, 99);
        Student_2 s7 = new Student_2("zlc", 97, 99);
        Student_2 s8 = new Student_2("zy", 97, 99);

        // 添加学生对象到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        ts.add(s8);

        // 遍历集合
        for (Student_2 s : ts) {
            System.out.println(s.getName() + "," + s.getChinese() +
                    "," + s.getMath() + "," + s.getSum());
        }
    }
}

Student_2的类

package com.zyj.demo_01;

public class Student_2 {
    private String name;
    private int chinese;
    private int math;

    public Student_2() {

    }

    public Student_2(String name, int chinese, int math) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
    }

    public String getName() {
        return name;
    }

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

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getSum() {
        return this.getChinese() + this.getMath();
    }
}

不重复的随机数

需求：编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出
思路:
1 :创建set集合对象2 :创建随机数对象
3:判断集合的长度是不是小于10
是:产生一个随机数，添加到集合回到3继续
4:遍历集合

package com.zyj.demo_01;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class SetDemo02 {
    public static void main(String[] args) {
        // 创建Set集合对象
//        Set<Integer> set = new HashSet<Integer>();
        Set<Integer> set = new TreeSet<Integer>(); // TreeSet会自动排序

        // 创建随机数对象
        Random r = new Random();

        // 判断集合的长度是否小于10
        while (set.size() < 10) {
            // 产生一个随机数，添加到集合
            int num = r.nextInt(20) + 1;
            set.add(num);
        }

        // 遍历集合
        for (Integer i : set) {
            System.out.println(i);
        }
    }
}

泛类

泛型类改进

public class Generic_2<T> {
    public void show(T t) {
        System.out.println(t);
    }
}

输出

package com.zyj.demo_01;

public class GenericDemo03 {
    public static void main(String[] args) {
        Generic_2<String> g1 = new Generic_2<>();
        g1.show("lqx");

        Generic_2<Integer> g2 = new Generic_2<>();
        g2.show(30);

        Generic_2<Boolean> g3 = new Generic_2<>();
        g3.show(true);
    }
}

--------------------------------------------------------------------------------------------------------------

泛型方法改进

public class Generic_3 {
    public <T> void show(T t) {
        System.out.println(t);
    }
}

输出

public class GenericDemo04 {
    public static void main(String[] args) {
        Generic_3 g = new Generic_3();
        g.show("lqx");
        g.show(30);
        g.show(true);
        g.show(12.22);
    }
}

Map集合

添加元素

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class MapDemo01 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();

        map.put("30","lqx");
        map.put("31","wzx");
        map.put("32","qsz");
        map.put("33","ly");

        System.out.println(map);
    }
}

Map集合遍历

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

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

        map.put("zwj", "zm");
        map.put("gj", "hr");
        map.put("yg", "xln");

        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> me : entries) {
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}

需求:创建一个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 HashMapDemo01 {
    public static void main(String[] args) {
        // 创建HashMap集合对象
        HashMap<String, Student04> hm = new HashMap<>();

        // 创建学生对象
        Student04 s1 = new Student04("lqx", 30);
        Student04 s2 = new Student04("zmy", 35);
        Student04 s3 = new Student04("wzx", 33);

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

        // 方式1：键找值
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            Student04 value = hm.get(key);
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }

        System.out.println("-----------------------------------------------");

        // 方式2：键值对对象找键和值
        Set<Map.Entry<String, Student04>> entries = hm.entrySet();
        for (Map.Entry<String, Student04> me : entries) {
            String key = me.getKey();
            Student04 value = me.getValue();
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
    }
}

需求:创建一个HashMap集合，键是学生对象(Student)，值是居住地(String)。存储多个键值对元素,并遍历。
要求:保证键的唯一性:如果学生对象的成员变量值相同，我们就认为是同一个对象
思路:
1. 定义学生类
2. 创建HashMap集合对象
3. 创建学生对象
4. 把学生添加到集合
5. 遍历集合
6. 在学生类中重写两个方法
hashCode()
equals()

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

public class HashMapDemo02 {
    public static void main(String[] args) {
        HashMap<Student04, String> hm = new HashMap<>();

        // 创建学生对象
        Student04 s1 = new Student04("lqx", 30);
        Student04 s2 = new Student04("zmy", 35);
        Student04 s3 = new Student04("wzx", 33);
        Student04 s4 = new Student04("wzx", 33);

        // 把学生添加到集合
        hm.put(s1,"xa");
        hm.put(s2, "wh");
        hm.put(s3, "zz");
        hm.put(s4, "bj"); // 应该是会覆盖wh，变成bj

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

这里需要重写一下equals()和hashCode()

import java.util.Objects;

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

    public Student04() {

    }

    public Student04(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;
        Student04 student04 = (Student04) o;
        return age == student04.age && Objects.equals(name, student04.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

需求:创建一个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 ArrayListIncludeHashMapDemo01 {
    public static void main(String[] args) {
        // 创建ArrayList集合
        ArrayList<HashMap<String, String>> array = new ArrayList<>();

        // 创建HashMap集合，并添加键值对元素
        HashMap<String , String > hm1 = new HashMap<String, String >();
        hm1.put("sc", "dq");
        hm1.put("zy", "xq");

        // 把HashMap作为元素添加到ArrayList集合
        array.add(hm1);

        // 创建HashMap集合，并添加键值对元素
        HashMap<String , String > hm2 = new HashMap<String, String >();
        hm2.put("gj", "hr");
        hm2.put("yg", "xln");

        // 把HashMap作为元素添加到ArrayList集合
        array.add(hm2);

        // 创建HashMap集合，并添加键值对元素
        HashMap<String , String > hm3 = new HashMap<String, String >();
        hm3.put("lhc", "ryy");
        hm3.put("lpz", "qls");

        // 把HashMap作为元素添加到ArrayList集合
        array.add(hm3);

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

需求:创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList，每一个ArrayList的元素都是String，并遍历。
要求:保证键的唯一性:如果学生对象的成员变量值相同，我们就认为是同一个对象
思路:
1. 创建HashMap集合
2. 创建ArrayList集合，并添加元素
3. 把ArrayList作为元素添加到HashMap集合
4. 遍历HashMap集合

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

public class HashMapIncludeArrayListDemo01 {
    public static void main(String[] args) {
        // 创建HashMap集合
        HashMap<String , ArrayList<String >> hm = new HashMap<>();

        // 创建ArrayList集合，并添加元素
        ArrayList<String> sgyy = new ArrayList<>();
        sgyy.add("zgl");
        sgyy.add("zy");

        // 把ArrayList作为元素添加到HashMap集合
        hm.put("sgyy", sgyy);

        // 创建ArrayList集合，并添加元素
        ArrayList<String> xyj = new ArrayList<>();
        xyj.add("ts");
        xyj.add("swk");

        // 把ArrayList作为元素添加到HashMap集合
        hm.put("xyj", xyj);

        // 创建ArrayList集合，并添加元素
        ArrayList<String> shz = new ArrayList<>();
        shz.add("ws");
        shz.add("lzs");

        // 把ArrayList作为元素添加到HashMap集合
        hm.put("shz", shz);

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

需求:键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。
举例:键盘录入 “aababcabcdabcde”在控制台输出:“a(5)b(4)c(3)d(2)e(1)”

要求:保证键的唯一性:如果学生对象的成员变量值相同，我们就认为是同一个对象
思路:
1. 键盘录入一个字符串
2. 创建HashMap集合，键是Character,值是Integer
3. 遍历字符串，得到每一个字符
4. 把得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
如果返回值不是null：说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
5. 遍历HashMap集合，得到键和值，按照要求进行拼接
6. 输出结果

import java.util.HashMap;
import java.util.Scanner;
import java.util.TreeMap;

public class HashMapDemo03 {
    public static void main(String[] args) {
        // 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        // 创建HashMap集合，键是Character,值是Integer
//        HashMap<Character, Integer> hm = new HashMap<>(); // HashMap不能排序
        TreeMap<Character, Integer> hm = new TreeMap<>(); // TreeMap可以直接排序

        // 遍历字符串，得到每一个字符
        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i);

            // 把得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
            Integer value = hm.get(key);

            if (value == null) { // 如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
                hm.put(key, 1);
            }else { // 如果返回值不是null：说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
                value++;
                hm.put(key, value);
            }
        }

        // 遍历HashMap集合，得到键和值，按照要求进行拼接
        StringBuilder stringBuilder = new StringBuilder();

        for (Character key : hm.keySet()) {
//            Integer value = hm.get(key);
            stringBuilder.append(key).append("(").append(hm.get(key)).append(")");
        }

//        String result = stringBuilder.toString();
        System.out.println(stringBuilder.toString());
    }
}

qq_43162004

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 学习 day3

常用类Iteratorpackage com.zyj.demo_01;import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class CollectionDemo { public static void main(String[] args) { // 创建Collection集合对象 Collec
复制链接

扫一扫