Java中Set集合的两种排序

Demo:

package jihe;

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

/**
 * set 集合中的 TreeSet集合
 * 
 * 需求:
 * 使用该集合存储多个学生的考试成绩信息(姓名、学号、语文成绩、数学成绩、历史成绩)
 * 
 * 要求:
 * 按照总分降序排序
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 95, 88, 76);
        Student s2 = new Student("李四", 67, 93, 84);
        Student s3 = new Student("王五", 88, 99, 77);
        Student s4 = new Student("赵六", 63, 75, 99);
        Student s5 = new Student("田七", 71, 66, 98);

        //自然排序
        nature(s1, s2, s3, s4, s5);

        System.out.println("\n\r");
        
        //比较器排序
        comp(s1,s2,s3,s4,s5);
    }

    /**
     * 自然排序
     *
     * @param s1
     * @param s2
     * @param s3
     * @param s4
     * @param s5
     */
    public static void nature(Student s1, Student s2, Student s3, Student s4, Student s5) {
        TreeSet<Student> st = new TreeSet<>();
        st.add(s1);
        st.add(s2);
        st.add(s3);
        st.add(s4);
        st.add(s5);

        for (Student s : st) {
            System.out.println("姓名:" + s.getName() + ",语文分数:" + s.getLangen() + ",数学分数:" + s.getMath() + ",历史分数:" + s.getHistory() + ",总分成绩:" + s.getTotal());
        }
    }

    /**
     * 比较强排序
     *
     * @param s1
     * @param s2
     * @param s3
     * @param s4
     * @param s5
     */
    public static void comp(Student s1, Student s2, Student s3, Student s4, Student s5) {

        //匿名对象
        TreeSet<Student> st = new TreeSet<>(new Comparator<Student>() {
            /**
             * 重写compareTo方法 实现自定义排序
             * @param o1 上一个元素
             * @param o2 当前元素
             * @return int 0、正数、负数
             * 返回 0 表示元素已存在,不会存储
             * 返回 正数 表示元素插入后面
             * 返回 负数 表示元素插入前面
             */
            @Override
            public int compare(Student o1, Student o2) {
                //这里降序排序
                int i = o1.getTotal() > o2.getTotal() ? -1 : 1;
                return i;
            }
        });

        st.add(s1);
        st.add(s2);
        st.add(s3);
        st.add(s4);
        st.add(s5);

        for (Student s : st) {
            System.out.println("姓名:" + s.getName()+",语文分数:"+s.getLangen() + ",数学分数:"+s.getMath() + ",历史分数:"+s.getHistory()+",总分成绩:"+s.getTotal());
        }
    }

}

Student类:

package jihe;

/**
 * 实现排序功能需要实现 Comparable 接口,并且指定 泛型 为需要操作的 引用数据 类型
 */
public class Student implements Comparable<Student> {
    String name;//姓名
    int langen;//语文成绩
    int math;//数学成绩
    int history;//历史成绩

    public Student(String name, int langen, int math, int history) {
        this.name = name;
        this.langen = langen;
        this.math = math;
        this.history = history;
    }

    public String getName() {
        return name;
    }

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

    public int getLangen() {
        return langen;
    }

    public void setLangen(int langen) {
        this.langen = langen;
    }

    public int getMath() {
        return math;
    }

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

    public int getHistory() {
        return history;
    }

    public void setHistory(int history) {
        this.history = history;
    }

    /**
     * 获取学生总分
     *
     * @return
     */
    public int getTotal() {
        return langen + math + history;
    }

    /**
     * 重写compareTo方法 实现自定义排序
     *
     * @param s 需要比较 的对象
     * @return int 0、正数、负数
     * 返回 0 表示元素已存在,不会存储
     * 返回 正数 表示元素插入后面
     * 返回 负数 表示元素插入前面
     */
    @Override
    public int compareTo(Student s) {
        //这里升序排序
        int i = this.getTotal() > s.getTotal() ? 1 : -1;
        return i;
    }
}

TreeSet的排序.png
NOTE:

  1. 由于Set集合的不保证排序方式,因此在Set集合的子类TreeSet类中提供了两种排序方式
  2. 自然排序和比较强排序
  3. 自然排序是在操作的对象中实现 Comparable 接口 (implements Comparable
  4. 比较器排序是在操作的对象实例化时提供构造参数 Comparable (implements Comparable

常见的数据结构

常见的数据结构:
栈:

  1. 数据进入栈模型的过程称为:进栈
  2. 数据取出栈模型的过程称为:出栈
  3. 栈就像是一个桶,只有顶部有出口
  4. 这种数据进出的模式 也就是: 先进后出(后进先出)

与栈对应的是队列

队列:

  1. 数据进入队列是从后端进入
  2. 数据取出队列是从前端离开
  3. 队列就像是一个管道,两端都有口子

数组:

  1. 数组是一种 查询快,增删慢的数据
  2. ArrayList底层数据结构就是数组

链表:

  1. 链表是一种 查询慢、增删快的数据(相比较于数组)
  2. LinkedList底层数据结构就是链表

ListIterator迭代器

package jihe;

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

/**
 * 列表迭代器
 * 1、该迭代器继承自 Iterator
 * 2、该迭代器允许倒序遍历
 * 3、可以插入数据
 */
public class ListiteraorDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("hello");
        list.add("world");
        list.add("java");

        //列表迭代器
        ListIterator<String> it = list.listIterator();

        //正序遍历
        while (it.hasNext()){
            String s = it.next();

            //添加元素 - 在最后一个元素后面添加
            if (s.equals("java")) {
                it.add("php");
            }
        }

        System.out.println(list);//[hello, world, java, php]


        System.out.println("\r\n");


        //倒序遍历
        while (it.hasPrevious()){
            System.out.println(it.previous());
        }



    }
}

NOTE:

  1. 该迭代器继承自 Iterator
  2. 该迭代器允许倒序遍历
  3. 迭代器中可以插入数据

List集合与迭代器

package jihe;

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

/**
 * List集合:
 * 1、该集合是有序集合(也成为序列)
 * 2、用户可以精确控制列表中每个元素的插入位置,可以通过数组索引的方式访问元素
 * 3、与Set集合不同,该集合允许重复的元素
 */
public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象 - 多态模式
        List<String> list = new ArrayList<>();
        list.add("第一个");
        list.add("第二个");
        list.add("第三个");
        list.add("第二个");//重复的元素

        System.out.println(list);//[第一个, 第二个, 第三个, 第二个]

        //获取集合中指定元素
        System.out.println(list.get(1));//第三个

        //在指定位置插入元素
        list.add(1,"我在哪里");//新插入的元素 将原位置及后面的元素全部往后位移+1
        System.out.println(list);//[第一个, 我在哪里, 第二个, 第三个, 第二个]

        //集合长度
        System.out.println(list.size());//5 元素长度

        //修改指定元素
        list.set(1,"我改变了");
        System.out.println(list);//[第一个, 我改变了, 第二个, 第三个, 第二个]

        //使用迭代器遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());//输出下一个元素
        }

    }
}

Collection集合与迭代器

package jihe;

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

/**
 * 集合类之:Collection
 * 集合类的特点:
 * 提供一种存储空间可变的存储模型,存储的数据容量可以随时发生改变
 * Java中的集合分为:Collection(单列) 和 Map(双列)
 * Connection集合:
 * 1、该集合包含 List、 Set两种集合
 * 2、存储数据只有一列数据
 * 3、List可存储重复数据
 * 4、Set不可存储重复数据
 * 5、List 集合包含:ArrayList、LinkedList等集合
 * 6、Set 集合包含:HashSet、TreeSet 等集合
 *
 * Map集合:
 * 1、存储数据有两列
 * 2、存储数据不可重复
 * 3、Map包含:HashMap等集合
 */
public class CollectionDemo {

    public static void main(String[] args) {
        //使用多态调用ArrayList集合
        Collection<String> c = new ArrayList<String>();
        //添加 add 方法返回的永远是true
        c.add("第一个");
        c.add("第二个");
        c.add("第一个");//重复的元素

        System.out.println(c);//[第一个, 第二个, 第一个]

        //移除元素
        c.remove("第一个");//从左到右 移除
        System.out.println(c);//[第二个, 第一个]


        System.out.println(c.contains("第一个1"));//返回 boolen

        //清空集合
        //c.clear();
        System.out.println(c);//[]

        //判断 集合 是否存在
        System.out.println(c.isEmpty());//如果为空 则返回true 否则 false

        System.out.println(c.size());//集合中元素个数

        /**
         * 集合的遍历
         * iterator 迭代器
         * 每个集合中都包含了一个 iterator 迭代器
         */
        Iterator<String> it = c.iterator();
        //判断迭代器中的下一个元素是否存在
        while (it.hasNext()) {
            System.out.println(it.next());//输出集合的下一个元素 注意:拿出一个后指针向后移动一位
        }



    }
}

NOTE:

  1. Collection和Map集合
  2. 单列集合和双列集合
  3. 集合中的迭代器:iterator

Java异常捕获

Demo

package tryDemo;


import java.io.*;

public class Demo {
    public static void main(String[] args) {
        /**
         * 手动捕获异常必须用try .. catch 结构、
         * 并且catch中包含指定抛出的异常类
         */
        /*try {
            int method = method(5);
            System.out.println(method);
        }catch (ArrayIndexException e){
            System.out.println(e.getMessage());
        }*/

        method1();
    }

    //跑抛出异常 注意:这里是 throws
    public static int method(int index) throws ArrayIndexException
    {
        int[] ar = {5,9,3,7};
        //判断索引是否存在数组中
        if (index < ar.length){
            return ar[index];
        }else{
            //捕获一个异常,并且手动抛出 注意:这里是 throw
            throw new ArrayIndexException("指定的数组索引不存在");
        }

    }


    /**
     * 文件异常 处理
     * 文件的一些操作需要抛出IOException异常
     * 为了简化文件操作的异常处理,有新的处理方式
     */
    public static void method1()
    {
        //将资源定义在 try() 里面
        try(InputStreamReader isr = new InputStreamReader(new FileInputStream("P:\\demo\\bbbbbb.txt"));){
            //读取文件
            char[] chs = new char[1024];
            int i;
            while ((i = isr.read(chs)) != -1){
                System.out.println(new String(chs,0,i));
            }
        }catch (IOException e){
            System.out.println(e);
        }
    }
}

自定义异常类

package tryDemo;

/**
 * 自定义数组索引异常类
 * 异常类定义:
 * 必须继承 Exception 异常基类
 * 并且实现带参构造方法
 * 使用构造方法将异常信息传递到super类
 */
public class ArrayIndexException  extends Exception{
    public ArrayIndexException(){
    }

    //message 异常信息
    public ArrayIndexException(String message) {
        super("数组异常:" + message);
    }
}

自定义异常.png

Java时间日期转换

package date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        //获取当前时间的时间戳(默认毫秒)
        Date d1 = new Date(System.currentTimeMillis());
        System.out.println(d1);
        System.out.println(d1.getTime());


        /**
         * 时间格式化处理
         */
        //将时间戳转换成日期时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//用指定的格式 来格式化时间和日期
        Date d = new Date();//获取当前是时间戳
        System.out.println(sdf.format(d));//将时间戳转换为日期格式
        String ss = sdf.format(d);
        System.out.println(ss);//2020-12-15 16:09:36

        //将时间转换成时间戳
        String dt = "2019-08-09 11:11:11";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            long ts = sdf1.parse(dt).getTime() / 1000;//不知道为什么 parse 这个方法必须放在try结构中才不会报错 我的jdk是15.1
            System.out.println(ts);
            //再试着转回去
            System.out.println(sdf.format(ts * 1000));//2019-08-09 11:11:11

        } catch (ParseException e) {
            e.printStackTrace();
        }




    }
}

Java数据处理

  1. 时间戳
  2. 数组排序
  3. string 和 int 互转
package inter;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        
        /**
         * Arrays 类 处理数组
         */
        //数组排序
        int[] arr = {12,58,36,54,11,45,74,61};
        System.out.println(Arrays.toString(arr));//[12, 58, 36, 54, 11, 45, 74, 61]
        Arrays.sort(arr);//排序
        System.out.println(Arrays.toString(arr));//[11, 12, 36, 45, 54, 58, 61, 74]


        /**
         * System 类 系统信息
         */
        //获取当前机器的毫秒时间戳
        long time = System.currentTimeMillis();
        System.out.println(time);//1608001816760
        //将毫秒时间戳转换为秒时间戳
        System.out.println(time / 1000);//1608001816

        //退出JVM虚拟机 status为负数表示异常退出
        //System.exit(-1);//进程已结束,退出代码-1

        /**
         * 基本数据类型的包装类
         * 基本数据类型       包装类
         * byte             Byte
         * shot             Short
         * int              Integer
         * long             Long
         * float            Float
         * double           Double
         * char             Characetr
         * boolean          Boolean
         */
        //例如:判断一个int的数据是否在int数据范围
        long i = 1545154586454L;
        System.out.println(i);//1545154586454
        System.out.println(Integer.MAX_VALUE);//2147483647
        System.out.println(Integer.MIN_VALUE);//-2147483648

        System.out.println((i > Integer.MAX_VALUE && i < Integer.MIN_VALUE) ? "该数据在int范围内" : "该数据不在int范围内");//该数据不在int范围内

        //将 string 转换为 integer 对象
        String s = "100";
        //System.out.println(Integer.valueOf("你好"));//报错 注意 该字符串必须是数字类型的字符串
        //方式一
        Integer s1 = Integer.valueOf(s);//先转换成 Integer 对象
        System.out.println(s1.intValue());//123456
        //方式二
        System.out.println(Integer.parseInt(s));//100

        //将 int 转换为 string 类型
        int number = 100;
        //方式一
        String s2 = "" + number;
        System.out.println(s2);//100
        //方式二
        System.out.println(String.valueOf(number));//100




    }
}

Java字符串处理

package str;

import java.util.Arrays;

/**
 * String
 * 字符串处理
 */
public class Str {
    public static void main(String[] args) {
        //字符串拆分
        String s = "91 27 46 38 50";
        String[] a = s.split(" ");//根据字符串中的拆分规律 " " 来拆分,并且拆分完成后的数据是一个数组(这是是将string拆分,因此返回的数据是string数组)
        System.out.println(a);//[Ljava.lang.String;@16b98e56 数组地址值
        System.out.println(Arrays.toString(a));//[91, 27, 46, 38, 50] 使用Arrays查看数组

        Integer ii = 100;
        System.out.println(ii.intValue() + 200);
    }
}

多态中的转型谷

Demo

package obj;

/**
 * 多态中的转型谷
 */
public class Dome {
    public static void main(String[] args) {
        /**
         * 实例化基类
         */
        //多态 - 向上转型
        Animal c = new Cat();
        System.out.println(c.name); // 动物
        //System.out.println(c.age); //报错,因为 Animal类中没有age属性
        c.skill(); //抓老鼠



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

        //子类正常调用方式
        /*Cat c1 = new Cat();
        System.out.println(c1.name);//猫
        System.out.println(c1.age);//5 不报错,因为 Cat 类中有age属性
        c1.skill();//抓老鼠*/


        /**
         * 以上方法虽然能够调用到子类中的属性
         * 但是 是实例化的一个新的对象
         *
         * 通过转型(向下转型将实例化的 Animal对象的实例转换成子类 )
         * Cat a = (Cat)Cat();
         */
        //向下转型
        Cat a = (Cat) c;//将 Animal对象的实例转换成子类
        System.out.println(a.age);//5




    }
}

基类

package obj;

public class Animal {
    String name = "动物";

    public void skill()
    {
        System.out.println("警惕");
    }
}

子类

package obj;

public class Cat extends Animal{
    String name = "猫";
    byte age = 5;

    public void skill() {
        System.out.println("抓老鼠");
    }
}