Java编程基础之自己敲的一些小Demo记录

Phone.java

public class Phone {
    /*
    类就是对象的数据类型，由属性和行为组成，行为方法就是普通方法去掉static
     */
    String brand;
    int price;
    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短信");
    }
}

PhoneDemo.java

public class PhoneDemo {
    public static void main(String[] args) {
        //对象的使用，创建phone对象
        Phone p = new Phone();
        //int的默认值为0
        System.out.println(p.price);
        //String的默认值为null
        System.out.println(p.brand);
        p.brand="xiaomi";
        p.price=1999;
        System.out.println(p.brand);
        System.out.println(p.price);
        p.call();
        p.sendMessage();
    }
}

运行截图

StringDemo.java

public class StringDemo {
    public static void main(String[] args) {
        //创建空白字符串，不包含任何内容
        String s6 = new String();
        System.out.println("空白字符串s6:"+s6);
        char[] chs = {'a','b','c'};
        String s7 =new String(chs);
        System.out.println("字符数组s7:"+s7);
        byte[] bys = {97,48,65};
        String s8 = new String(bys);
        System.out.println("字节数组s8:"+s8);
        // "==" 与 equals 的区别
        /*
        比较两种类型：基本数据类型和引用类型
         */
        int a =10;
        int b =10;
        int c =20;
        //没有new 的对象会被分配在常量池中
        String s1="10";
        String s2="10";
        String s3="20";
        String s4 = new String(s3);
        String s5 = new String(s3);
        //每new一次，都会在堆内存中开辟出新的内存空间进行存储
        Student stu1 = new Student("雷军",30);
        Student stu2 = new Student("雷军",30);
        System.out.println(a==b);
        //true
        System.out.println(s1.equals(s2));
        //true
        System.out.println(s4==s5);
        //false , 当比较引用类型的时候，== 比较的是地址是否相同，比较两个引用变量，是否指向同一个存储地址。
        System.out.println(s4.equals(s5));
        //true ,因为String,Integer重写了equals方法，将引用的比较改成了值的比较，相当于“==”
        System.out.println(s3==s4);
        //false ,引用类型比较，两个对象指向不同内存地址
        System.out.println(s3.equals(s4));
        //true ,引用类型比较相当与"=="值的比较
        System.out.println(stu1==stu2);
        //false ,引用类型比较，比较引用地址是否相同
        System.out.println(stu1.equals(stu2));
        //false ,引用类型比较，没有重写equals方法，比较引用地址是否相同。

    }
}

运行截图

StringDemo1.java

import java.util.Scanner;
public class StringDemo1 {
    public static void main(String[] args) {
        //输入一个字符串，并在控制台打印输入的字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s1 = sc.nextLine();
        for (int i =0 ; i<s1.length();i++){
            System.out.print(s1.charAt(i));
        }
        //字符串拼接，定义一个方法，将int[]数组按照指定的字符串格式进行拼接
        int[] arr = {1,2,3};
        String s2 = arrToString(arr);
        System.out.println("s2:"+s2);
        //键盘录入abc,输出cda 字符串反转
//        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String s = sc.nextLine();
        String res = reverse(s);
        System.out.println(res);
    }
    private static String reverse(String s) {
        //字符串反转，将字符串倒着遍历，存入到空字符串
        String ss= "";
        for (int i=s.length()-1;i>=0;i--){
            ss+=s.charAt(i);
        }
        return ss;
    }
    private static String arrToString(int[] arr) {
        //定义一个空字符串，来接收int[]
        String s = "";
        s+="[";
        for (int i =0;i<arr.length;i++){
            if(i==arr.length-1){
                s+=arr[i];
            }else {
                s+=arr[i]+",";
            }
        }
        s+="]";
        return s;
    }
}

运行截图

StringBuilderDemo.java

import java.util.Scanner;
public class StringBuilderDemo {
    public static void main(String[] args) {
//        //创建StringBuilder对象
//        StringBuilder sb = new StringBuilder();
//        System.out.println("sb:"+sb);
//        //默认的对象值为空
//        System.out.println("sb.length:"+sb.length());
//        //长度为0
//        StringBuilder sb1 = new StringBuilder("hello");
//        System.out.println(sb1);
//        System.out.println(sb1.length());
////        sb1.append("world");
////        sb1.append("java");
//        sb1.append("world").append("java");
//        System.out.println(sb1);
//        //字符串反转方法
//        sb1.reverse();
//        System.out.println(sb1);
//        //StringBuild与String互相转换
//        //StringBuild-->Sting 只需要调用toString()方法即可
//        StringBuilder sb = new StringBuilder("hello");
//        String s = sb.toString();
//        System.out.println(s);
//
//        //String-->StringBuild  通过构造方法转换
//        String s1 = "hello";
//        StringBuilder sb1= new StringBuilder(s1);
//        System.out.println(sb1);
        /**
         * 字符串拼接
         */
        //定义一个数组
        int[] arr = {1,2,3,4,5,6};
        String s = arrToString(arr);
        System.out.println("s:"+s);
        /**
         * 字符串反转
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String s1 = sc.nextLine();
        String s2 = reserve(s1);
        System.out.println(s2);
    }
        private static String arrToString(int[] arr) {
        StringBuilder sb =new StringBuilder();
        sb.append("[");
        for (int i = 0;i<arr.length;i++){
            if(i==arr.length-1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        String s =sb.toString();
        return s;
    }

    private static String reserve(String s1) {
        //用StringBuild
        StringBuilder sb = new StringBuilder(s1);
        sb.reverse();
        String s=sb.toString();
        return s;
    }
}

运行截图

EqualsDemo.java

邮箱格式通过正则表达式进行验证

import java.util.Scanner;
public class EqualsDemo {
    /**
    用equals验证用户名和密码，
     */
    public static void main(String[] args) {
        String username = "itheibai";
        String password = "123456";
        String email = "123456@qq.com";
        Scanner sc = new Scanner(System.in);
        //需求：登录错误三次，结束程序
        for (int i=0;i<3;i++){
            System.out.println("请输入用户名：");
            String username1 = sc.nextLine();
            if(username.equals(username1)){
                System.out.println("请输入密码：");
                String password1 = sc.nextLine();
                if(password.equals(password1)){
                    System.out.println("请输入邮箱：");
                    String email1 = sc.nextLine();
                    if (email1.matches("^(\\w+([-.][A-Za-z0-9]+)*){3,18}@\\w+([-.][A-Za-z0-9]+)*\\.\\w+([-.][A-Za-z0-9]+)*$")){
                        if(email.equals(email1)){
                            System.out.println("登录成功");
                            break;
                        }else {
                            if(2-i==0){
                                System.out.println("锁定");
                            }else {
                                System.out.println("邮箱错误，你还有"+(2-i)+"次登录机会");
                            }
                        }
                    }else {
                        if(2-i==0){
                            System.out.println("锁定");
                        }else {
                            System.out.println("邮箱格式错误，你还有"+(2-i)+"次登录机会");
                        }
                    }
                }else {
                    if(2-i==0){
                        System.out.println("锁定");
                    }else {
                        System.out.println("密码错误，你还有"+(2-i)+"次登录机会");
                    }
                }
            }else {
                if(2-i==0){
                    System.out.println("锁定");
                }else {
                    System.out.println("用户名错误，你还有"+(2-i)+"次登录机会");
                }
            }
        }

    }
}

运行截图

ArrayDemo.java

import java.util.Scanner;

public class ArrayDemo {
    public static void main(String[] args) {
//        //动态初始化数组,就是通过new来创建，给定数组长度
//        int arr[] = new int[3];
//        System.out.println(arr);
//        //[I@1b6d3586  数组在堆内存中的地址
//        //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException  数组越界异常
//        //arr = null;
//        //NullPointerException  空指针异常
//        System.out.println(arr[0]);
//        System.out.println(arr[1]);
//        System.out.println(arr[2]);
//
//
//        //静态初始化数组，就是直接给定具体的数组元素值
//        int arr1[] = {1,2,3};
//        System.out.println(arr1);
//        //[I@4554617c  数组在堆内存中的地址
//        System.out.println(arr1[0]);
//        //通用遍历数组格式
//        for (int i = 0; i<arr1.length;i++){
//            System.out.println(arr1[i]);
//        }
//        //求数组中的最大值
//        int max=arr1[0];
//        for (int i=1;i<arr1.length;i++){
//            if(max<arr1[i]){
//                max=arr1[i];
//            }
//        }
//        System.out.println("max:"+max);
        //数组格式化，要求输出格式为[2, 4, 6, 1, 3, 5]
        int[] arr2 = {2,4,6,1,3,5};
//        System.out.println(arr2.length);
//        System.out.print("[");
//        for (int i=0;i<arr2.length;i++){
//            if(i==arr2.length-1){
//                System.out.print(arr2[i]);
//            }else {
//                System.out.print(arr2[i]+", ");
//            }
//        }
//        System.out.println("]");
        //调用方法，对数组进行格式化输出
        arrFormat(arr2);
//        //逢七过，要求100以内，数到个位、十位为7和能被7整除的数字的人，喊过。输出都有哪些数字
//        for(int i=1;i<100;i++){
//
//            if(i%7==0||i/10%10==7||i%10==7){
//                System.out.println("逢七过的数字有："+i);
//            }
//        }
        //定义一个方法来比较两个数组是否相同
        int[] arr = {1,2,3,4,5,6};
        int[] arr1 = {1,2,3,4,5,6};
        boolean flag = compare(arr,arr1);
        System.out.println("arr[]和arr1[]数组是否相同："+flag);
        //已知一个数组arr2,键盘录入一个数据，查找该数据在数组中的索引，并输出，如果没有查到，则输出-1
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int i = sc.nextInt();
        int flag1 = -1;
        for (int j=0;j<arr2.length;j++){
            if(i==arr2[j]){
                flag1=j;
            }
        }
        if(flag1==-1){
            System.out.println("该数据在数组中不存在");
        }else {
            System.out.println("该数据在数组中的索引为："+flag1);
        }
        //定义一个方法，实现数组反转
        reverse(arr2);
        arrFormat(arr2);
        /**
         * 定义方法实现，键盘输入6个（1-100）整数分，去掉一个最高分和最低分后的平均分（不考虑小数部分）
         */
//        Scanner sc = new Scanner(System.in);
        //创建一个数组用来存储6个分数
        int[] arr3 = new int[6];
        //通过for循环来实现6次键盘录入
        for (int j=0;j<arr3.length;j++){
            System.out.println("请输入第"+(j+1)+"个分数：");
            arr3[j] = sc.nextInt();
        }
        //调用获取最大值的方法
        int max = getMax(arr3);
        //调用获取最小值的方法
        int min = getMin(arr3);
        //调用数组求和方法
        int sum = getSum(arr3);
        //将/4换成/(arr3.length-2)可以让程序更加的健壮
        int avg=(sum-max-min)/(arr3.length-2);
        System.out.println("平均分为："+avg);
    }
    private static int getSum(int[] arr3) {
        int sum = 0;
        for (int i=0;i<arr3.length;i++){
            sum+=arr3[i];
        }
        return sum;
    }
    private static int getMin(int[] arr3) {
        int min=arr3[0];
        for (int i = 1;i<arr3.length;i++){
            if(min>arr3[i]){
                min=arr3[i];
            }
        }
        return min;
    }
    private static int getMax(int[] arr3) {
        int max = arr3[0];
        for(int i=1;i<arr3.length;i++){
            if(max<arr3[i]){
                max=arr3[i];
            }
        }
        return max;
    }
    /**
     * 数组反转
        两个明确：
        返回值void
        参数：int[] arr2
     */
    private static void reverse(int[] arr2) {
        //定义两个索引变量，一个开始变量，一个结束变量，当开始变量小于等于结束变量时，交换数值。
        int start;
        int end;
        for (start = 0,end = arr2.length-1;start<=end;start++,end--){
            int temp = arr2[start];
            arr2[start]=arr2[end];
            arr2[end]=temp;
        }
    }
    /**
     * 比较两个数组是否相同，首先比较长度是否一样，长度不一样直接退出，其次在判断内容是否一样
     * @param arr
     * @param arr1
     * @return
     */
    private static boolean compare(int[] arr, int[] arr1) {
        //首先先比较数组长度是否一样
        if (arr.length!=arr1.length){
            return false;
        }
        for (int i =0;i<arr.length;i++){
            if (arr[i]!=arr1[i]){
                return false;
            }
        }
        return true;
    }
    public static void arrFormat(int[] arr){
        System.out.println("数组长度为："+arr.length);
        System.out.print("[");
        for (int i=0;i< arr.length;i++){
            if (i==arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+", ");
            }
        }
        System.out.println("]");
    }
}

运行截图

StudentDemo.java

public class StudentDemo {
    public static void main(String[] args) {
        //通过无参构造方法进行初始化
        Student s1 = new Student();
        Student s2 = new Student();
        s1.setName("雷军");
        s1.setAge(40);
        s1.getAge();
        s1.getName();
        s2.setName("马云");
        s2.setAge(50);
        s2.show();
        s1.show();
        //通过带参构造方法进行初始化
        Student s3 = new Student("马化腾",39);
        s3.show();
    }
}

运行截图

Student.java

public class Student {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<0||age>120){
            System.out.println("您输入的年龄有误！");
        }else {
            this.age = age;
        }
    }
    //构造方法的功能就是用来初始化对象数据，每创建一个对象，都会对对象数据进行初始化。
    public Student() {
        System.out.println("无参构造方法");
    }
    //带参构造方法，可以对成员变量进行初始化，设置初始化值
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show(){
        System.out.println("name:"+name+","+"age:"+age);
    }
}

ArrayListDemo.java

import java.util.ArrayList;
public class ArrayListDemo {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList<String> array = new ArrayList<String>();
        System.out.println(array);
        //输出“[]”
        System.out.println(array.size());
        //输出 0
        //添加元素
        array.add("hello");
        array.add("world");
        array.add("java");
        System.out.println(array);
        //输出  [hello, world, java]
        //修改指定索引处的元素set(index,value)，返回被删除的元素
        String hi = array.set(0, "hi");
        System.out.println(hi);
        //输出 hello
        //获取指定索引处的元素get()
        String g = array.get(1);
        System.out.println(g);
        System.out.println(array);
        //  [hi, world, java]
        //删除指定的元素remove(value),返回是否删除成功
        boolean re = array.remove("hi");
        System.out.println(re);
        //删除指定索引处的元素remove(index)，返回被删除的元素
        String rei = array.remove(1);
        System.out.println(rei);
        System.out.println(array);
        System.out.println(array.size());
        //遍历集合，通用遍历格式,通过get(index)方法获取每一个值，size()方法获取集合的长度
        for (int i=0;i<array.size();i++){
            String g1 = array.get(i);
            System.out.println(g1);
            /**
             * 遍历结果
             * hello
             * world
             * java
             */
        }

        //创建学生对象集合
        ArrayList<Student> arrays = new ArrayList<Student>();
        //创建三个学生对象，进行遍历
        Student s1 = new Student("雷军",39);
        Student s2 = new Student("马云",48);
        Student s3 = new Student("马云",50);
        arrays.add(s1);
        arrays.add(s2);
        arrays.add(s3);
        //遍历
        for (int i =0;i<arrays.size();i++){
            Student student = arrays.get(i);
            System.out.println(student);
            /**
             * 输出
             * Student@1b6d3586
             * Student@4554617c
             * Student@74a14482
             */
            System.out.println(student.getName()+","+student.getAge());
            /**
             * 雷军,39
             * 马云,48
             * 马云,50
             */
        }
    }
}

运行截图

Student1.java

/**
 * 用于键盘输入学生属性，为了使用方便，属性类型设置为String
 */
public class Student1 {
    private String name;
    private String age;
    public Student1(String name, String age) {
        this.name = name;
        this.age = age;
    }
    public Student1() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
}

ArrayListDemo1.java

import java.util.ArrayList;
import java.util.Scanner;
public class ArrayListDemo1 {
    public static void main(String[] args) {
        //通过键盘录入学生信息，存储到集合中，并进行遍历
        //创建集合，
        ArrayList<Student1> array = new ArrayList<Student1>();
        //通过调用方法实现学生录入
        addStudent(array);
        addStudent(array);
        addStudent(array);
        //进行遍历
        for (int i=0;i<array.size();i++){
            Student1 s = array.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
    }
    private static void addStudent(ArrayList<Student1> array) {
        //创建输入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入姓名：");
        String name=sc.nextLine();
        System.out.println("请输入年龄：");
        String age = sc.nextLine();
        //创建学生对象
        Student1 s = new Student1();
        s.setName(name);
        s.setAge(age);
        //将学生对象添加到集合
        array.add(s);
    }
}

运行截图

Student2.java

public class Student2 {
    private int sid;
    private String name;
    private int age;
    public Student2() {
    }
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    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;
    }
    public Student2(int sid, String name, int age) {
        this.sid = sid;
        this.name = name;
        this.age = age;
    }
    /**
     * 第一种排序，可以实现Compareble接口，重写compareTo方法
     * public class Student2 implements Comparable
     * @param o
     * @return
     */
//    @Override
//    public int compareTo(Object o) {
//        //对引用数据类型排序，必须实现Comparable接口中的此方法.
//        Student2 stu=(Student2) o;
//        int num=this.getAge()-stu.getAge();
//        //年龄相同之后再比较姓名
//        int num1=num==0?this.getName().compareTo(stu.getName()):num;
//        return num1;
//    }
}

ArrayListStudentDemo.java

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
public class ArrayListStudentDemo {
    public static void main(String[] args) {
//        //创建一个集合
//        ArrayList<Student2> array = new ArrayList<Student2>();
//        Student2 s1 = new Student2(1,"雷军",121);
//        array.add(s1);
//        for (int i = 0;i<array.size();i++){
//            Student2 s = array.get(i);
//            System.out.println(s.getSid()+","+s.getName()+","+s.getAge());
//        }
        //创建ArrayList集合，存储类型为Student2
        ArrayList<Student2> array = new ArrayList<Student2>();
        //这里的数据可以在，测试完findAllStudent方法后添加，方便测试排序
        Student2 s1 = new Student2(1,"a",21);
        Student2 s2 = new Student2(2,"b",12);
        Student2 s3 = new Student2(3,"c",32);
        Student2 s4 = new Student2(4,"d",12);
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        while (true){
            System.out.println("------------学生信息管理系统-------------");
            System.out.println("1-查询学生列表");
            System.out.println("2-添加学生信息");
            System.out.println("3-修改学生信息");
            System.out.println("4-删除学生信息");
            System.out.println("5-学生按年龄从小到大排序");
            System.out.println("6-学生按年龄从大到小排序");
            System.out.println("7-首先按年龄排序，相等按姓名排序(升序)");
            System.out.println("8-退出系统");
            System.out.println("--------------------------------------");

            Scanner sc = new Scanner(System.in);
            System.out.println("请从1-8选择功能使用：");
            String line = sc.nextLine();
            //选择功能采用switch语句
            switch(line){
                case "1":
                    findAllStudent(array);
                    break;
                case "2":
                    addStudent(array);
                    break;
                case "3":
                    setStudent(array);
                    break;
                case "4":
                    deleteStudent(array);
                    break;
                case "5":
                    sortStudentAsc(array);
                    break;
                case "6":
                    sortStudentDesc(array);
                    break;
                case "7":
                    sortComparatorStudent(array);
                    break;
                case "8":
                    System.out.println("谢谢使用本系统，已安全退出");
                    //JVM退出
                    System.exit(0);
            }
        }
    }
    /**
     * 第二种排序，比较器的方式，以匿名内部类的方式传入，或着新建一个比较器类，在传入
     * 首先按照年龄进行排序，年龄相同则按照姓名进行排序（默认为升序）
     * @param array
     */
    private static void sortComparatorStudent(ArrayList<Student2> array) {
        //通过比较器进行排序，以匿名内部类的方式传入
        array.sort(new Comparator<Student2>() {
            @Override
            public int compare(Student2 o1, Student2 o2) {
                int num = o1.getAge()-o2.getAge();
                int num1 = num==0?o1.getName().compareTo(o2.getName()):num;
//                //降序desc
//                int num = o2.getAge()-o1.getAge();
//                int num1 = num==0?o2.getName().compareTo(o1.getName()):num;
                return num1;
            }
        });
        System.out.println("学号\t\t姓名\t\t\t年龄");
        //使用增强for进行遍历
        for (Student2 stu:array){
            System.out.println(stu.getSid()+"\t\t"+stu.getName()+"\t\t\t"+stu.getAge());
        }
    }
    /**
     * 第三种排序，冒泡排序
     * @param array
     */
    private static void sortStudentDesc(ArrayList<Student2> array) {
        //按照年龄从大到小进行排序（降序Desc）,此处采用冒泡排序
        for (int i= 0;i<array.size()-1;i++){
            for(int j = 0;j<array.size()-1-i;j++){
                if (array.get(j).getAge()<array.get(j+1).getAge()){
                    Student2 temp = array.get(j);
                    array.set(j,array.get(j+1));
                    array.set(j+1,temp);
                }
            }
        }
        System.out.println("学号\t\t姓名\t\t\t年龄");
        for (Student2 stu:array){
            System.out.println(stu.getSid()+"\t\t"+stu.getName()+"\t\t\t"+stu.getAge());
        }
    }
    private static void sortStudentAsc(ArrayList<Student2> array) {
        //按照年龄从小到大进行排序（升序Asc）.此处采用冒泡排序
        for (int i=0;i<array.size()-1;i++){
            for(int j= 0;j<array.size()-1-i;i++){
                if (array.get(j).getAge()>array.get(j+1).getAge()){
                    Student2 temp =array.get(j);
                    array.set(j,array.get(j+1));
                    array.set(j+1,temp);
                }
            }
        }
        System.out.println("学号\t\t姓名\t\t\t年龄");
        for (Student2 stu:array){
            System.out.println(stu.getSid()+"\t\t"+stu.getName()+"\t\t\t"+stu.getAge());
        }
    }
    private static void deleteStudent(ArrayList<Student2> array) {
        Scanner sc = new Scanner(System.in);
        Scanner ic = new Scanner(System.in);
        int sid;
        while (true){
            System.out.println("请输入学号：");
            sid = ic.nextInt();
            if (isExist(array,sid)){
                break;
            }else {
                System.out.println("该学号不存在，请重新输入学号进行删除！");
            }
        }
        //遍历集合，通过学号在集合中找到对应的索引，进行删除
        for (int i=0;i<array.size();i++){
            Student2 s3 = array.get(i);
            if(s3.getSid()==sid){
                array.remove(i);
            }
        }
        System.out.println("删除成功！");
    }
    private static void addStudent(ArrayList<Student2> array) {
        //添加学生之前，要先判断要添加的学号在集合中是否已存在，通过方法进行判断，isExist(array,sid)
        Scanner sc = new Scanner(System.in);
        Scanner ic = new Scanner(System.in);
        int sid;
        while(true){
            System.out.println("请输入学号：");
            sid = ic.nextInt();
            if (isExist(array, sid)){
                System.out.println("该学号已存在，请重新输入！");
            }else {
                break;
            }
        }
        System.out.println("请输入姓名：");
        String name = sc.nextLine();
        System.out.println("请输入年龄：");
        int age = ic.nextInt();
        //创建学生对象
        Student2 s = new Student2();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        array.add(s);
        System.out.println("添加学生成功！");
    }
    private static boolean isExist(ArrayList<Student2> array, int sid) {
        boolean flag=false;
        for (int i=0;i<array.size();i++){
            Student2 s = array.get(i);
            if (s.getSid()==sid){
                flag=true;
                break;
            }
        }
        return flag;
    }
    private static void findAllStudent(ArrayList<Student2> array) {
        //查询数据前，要先判断集合是否为空
        if(array.size()==0){
            System.out.println("请添加数据后在进行查询功能！");
            return;
        }
        System.out.println("学号\t\t姓名\t\t\t年龄");
        for (int i=0;i<array.size();i++){
            Student2 s = array.get(i);
            System.out.println(s.getSid()+"\t\t"+s.getName()+"\t\t\t"+s.getAge());
        }
    }
    public static void setStudent(ArrayList<Student2> array) {
        Scanner sc = new Scanner(System.in);
        Scanner ic = new Scanner(System.in);
        int sid;
        while(true){
            System.out.println("请输入要修改的学生学号：");
            sid = ic.nextInt();
            if(isExist(array,sid)){
                break;
            }else {
                System.out.println("该学号不存在，请重新输入要修改的学号！");
            }
        }
        System.out.println("请输入修改后的姓名：");
        String name = sc.nextLine();
        System.out.println("请输入修改后的年龄：");
        int age = ic.nextInt();
        //创建学生对象
        Student2 s = new Student2();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        //要通过遍历集合，获取要修改对象的索引，并不是直接用学号做索引,而是找到该学号在集合中的索引位置。
        for (int i=0;i<array.size();i++){
            Student2 s1 = array.get(i);
            if (s1.getSid()==sid){
                array.set(i,s);
            }
        }
        System.out.println("修改信息成功！");
    }
}

运行截图

Fu.java

public class Fu {
    int num =10;
    public void show(){
        System.out.println("父类show()方法被调用");
    }
}

Zi.java

/**
 * 继承支持 单继承 和 多层继承（ b extends a ; c extends b ） ，不支持多继承( c extends a,b )。
 */
public class Zi extends Fu{
    int num =20;
    //注释掉num=20和num=30,会输出 10
    /**
     * 子类方法访问变量的范围，采取就近原则，先在子类中查找变量，子类中没有，则在父类中查找。
     * 子类中所有构造方法默认都会访问父类中的无参构造方法，因为，每一个子类构造方法的第一条语句默认都是：super（）
     */
    @Override
    public void show(){
        System.out.println("调用子类重写父类方法");
        int num =30;
        System.out.println(num);
        //输出 30
//        System.out.println(num);
        //注释掉，num=30,会输出 20
        System.out.println(this.num);
        //输出本类中的成员变量20
        System.out.println(super.num);
        //输出父类中的成员变量10
    }
    public void method(){
        System.out.println("子类method()方法被调用");
    }
}

ExtendsDemo.java

public class ExtendsDemo {
    public static void main(String[] args) {
        //创建父类对象
        Fu f = new Fu();
        f.show();
        //创建子类对象
        Zi z = new Zi();
        z.show();
        z.method();
        /**
         * 输出
         * 父类show()方法被调用
         * 父类show()方法被调用
         * 子类method()方法被调用
         */

    }
}

运行截图

Animal.java

public class Animal {
    public int age = 40;
    public void eat(){
        System.out.println("动物吃东西");
    }
}

Cat.java

/**
 * 多态，就是同一个对象，在不同时刻表现出来的不同形态；
 * 前提：要有集成或实现的关系，要有方法的实现，要有父类引用指向子类对象
 */
public class Cat extends Animal{
    public int age = 20;
    public int weight =10;
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

AnimalDemo.java

/**
 * 成员变量：编译看父类，运行看父类
 * 成员方法：编译看父类，运行看子类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //以多态的形式创建对象，父类引用指向子类对象（向上转型）
        Animal an = new Cat();
        System.out.println(an.age);
        //输出 40
//        System.out.println(an.weight);
        //父类无法访问子类成员变量
        an.eat();
        //输出  猫吃鱼
//        an.playGame();
        //父类无法访问子类成员方法
        /**
         * 向下转型
         */
        Cat c = (Cat) an;
        System.out.println(c.age);
        System.out.println(c.weight);
        c.playGame();
    }
}

运行截图

Animal1.java

/**
 * 抽象类中可以有变量和常量，无参构造和带参构造，抽象方法和普通方法
 */
public abstract class Animal1 {
    private int age=20;
    private final String city = "北京";
    public Animal1() {
    }
    public Animal1(int age) {
        this.age = age;
    }
    public void show(){
        age = 40;
        System.out.println(age);
//        city="上海";
        System.out.println(city);
    }
    public abstract void eat();
}

Dog.java

/**
 * 抽象类的子类要么重写父类的所有抽象方法，要么子类是抽象类
 * 注解用来校验重写的方法名是否正确
 */
public class Dog extends Animal1{
    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }
}

AnimalAbstractDemo.java

public class AnimalAbstractDemo {
    public static void main(String[] args) {
        //抽象类不能直接实例化，要通过多态的形式进行实例化
        Animal1 a = new Dog();
        a.show();
        a.eat();
    }
}

运行截图

Inter.java

/**
 * 接口中的成员变量只能是常量，构造方法只能是抽象方法，默认方法为：public private
 */
public interface Inter {
    public int num = 10;
    public final int num2=20;
    public static final int num3=30;
    int num4 =30;
    public abstract void method();
    void show();
}

InterImpl.java

public class InterImpl extends Object implements Inter{
    public InterImpl(){
        super();
    }
    @Override
    public void method(){
        System.out.println("method");
    }
    @Override
    public void show(){
        System.out.println("show");
    }
}

InterDemo.java

public class InterDemo {
    public static void main(String[] args) {
        //接口不能直接实例化，只能通过多态的形式进行实例化
        Inter i = new InterImpl();
        i.show();
        i.method();
//        System.out.println(i.num);
        //i.num访问不到，
        System.out.println(Inter.num);
        System.out.println(Inter.num2);
        System.out.println(Inter.num3);
        System.out.println(Inter.num4);
    }
}

运行截图

Outer.java

/**
 * 内部类访问特点：
 * 内部类可以直接访问外部类的成员，包括私有
 * 外部类要访问内部类的成员，必须创建对象（实例化）访问
 * 目的：
 * 大多数是不想让外界去访问，所以将内部类定义为私有化，然后在提供一个方法来调用（在方法内部创建内部类对象并调用）
 */
public class Outer {
    private int num = 10;
    private class Inner{
        public void show(){
            System.out.println("外部类中num:"+num);
        }
    }
    public void method(){
        Inner i = new Inner();
        i.show();
    }
}

InnerDemo.java

public class InnerDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

运行截图

SystemDemo.java

/**
 * 常用API，System
 * 常用方法：System.exit(0) 终止当前运行的Java虚拟机，非 0 表示异常终止
 */
public class SystemDemo {
    public static void main(String[] args) {
        //获取当前的开始时间节点
        long start = System.currentTimeMillis();
        for(int i=1;i<10000;i++){
            System.out.println(i);
        }
        //获取执行结束时间节点
        long end = System.currentTimeMillis();
        System.out.println("共耗时："+(end-start)+"毫秒");
    }
}

运行截图

ToString.java

/**
*Object类的toString方法
*/
public class ToString extends Object{
    private String name;
    private int age;
    public ToString() {
    }
    public ToString(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 String toString() {
        return "ToString{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

ToStringDemo.java

public class ToStringDemo {
    public static void main(String[] args) {
        ToString t1 = new ToString("leijun",36);
        ToString t2 = new ToString("leijun",36);
        System.out.println(t1);
        System.out.println(t2.toString());
    }
}

运行截图

EqualsObject.java

import java.util.Objects;
/**
 * Object类的equals方法，用于对象之间的比较。
 * 场景：如果不希望比较对象的地址值，想要比较对象的属性时，需要重写equals方法
 */
public class EqualsObject {
    private String name;
    private int age;
    public EqualsObject() {
    }
    public EqualsObject(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;
    }
    /**
     * 重写equals方法
     * @param o
     * @return
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        EqualsObject that = (EqualsObject) o;
        return age == that.age && Objects.equals(name, that.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

EqualsObjectDemo.java

public class EqualsObjectDemo {
    public static void main(String[] args) {
        EqualsObject e1 = new EqualsObject("leijun",36);
        EqualsObject e2 = new EqualsObject("leijun",36);
        EqualsObject e3 = new EqualsObject("mayun",36);
        System.out.println(e1.equals(e2));
        System.out.println(e1.equals(e3));
    }
}

运行截图

ArraysDemo.java

import java.util.Arrays;
/**
 * 冒泡排序
 * Arrays的常用方法：toString() , sort()
 *常用的引用类型有：类，数组，接口
 */
public class ArraysDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {2,4,6,1,3,5};
//        for(int i=0;i<arr.length;i++){
//            System.out.print(arr[i]+" ");
//        }
        //输出 2 4 6 1 3 5
        //定义方法，实现数组按指定格式输出（字符串拼接）,
        System.out.println("排序前：");
        arrToString(arr);
        //冒泡排序,定义一个方法实现
        arrSort(arr);
        System.out.println("排序后：");
        arrToString(arr);
        //调用Arrays的sort()方法
        Arrays.sort(arr);
        System.out.println("排序后：");
        Arrays.toString(arr);
        arrToString(arr);
    }
    private static void arrSort(int[] arr) {
        for (int i=0;i<arr.length-1;i++){
            for (int j=0;j<arr.length-1-i;j++){
                if (arr[j]>arr[j+1]){
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                }
            }
        }
    }
    private static void arrToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i=0;i<arr.length;i++){
            if (i==arr.length-1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        System.out.println(s);
    }
}

运行截图

IntegerDemo.java

import javax.xml.soap.SOAPMessage;
import java.util.Arrays;
public class IntegerDemo {
    public static void main(String[] args) {
        //String-->int
        String s="100";
        //方式一
        Integer i = Integer.valueOf(s);
        //返回一个Integer对象的 string
        int i1 = i.intValue();
        System.out.println(i1);
        //方式二
        int i2 = Integer.parseInt(s);
        System.out.println(i2);
        System.out.println("---------------------");
        //int-->string
        int a = 101;
        //方式一，在后面添加空字符串
        String s3 = a+"";
        System.out.println(s3);
        //方式三
        String s4 = String.valueOf(a);
        System.out.println(s4);
        System.out.println("------------------");
        //对字符串进行排序，输出格式为 “1 2 3 4 5 6”
        String s5="2 4 6 1 3 5";
        //1.创建String字符串数组，以空格为分割符进行存储
        String[] strArray = s5.split(" ");
        //2.创建int[]存储，将字符串转换为int类型，为排序做准备
        int[] arr = new int[strArray.length];
        //3.转换
        for (int j=0;j<arr.length;j++){
            arr[j] = Integer.parseInt(strArray[j]);
        }
        //4.排序
        Arrays.sort(arr);
        //5.拼接成指定格式
        StringBuilder sb = new StringBuilder();
        for (int k =0;k<arr.length;k++){
            sb.append(arr[k]).append(" ");
        }
        String s6 = sb.toString();
        System.out.println(s6);
    }
}

运行截图

DateDemo.java

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
/**
 * MM 月份是0-11   ，DD 日是1-31
 * MySql中三种时间数据类型
 * 1.Date数据类型，用来存储没有时间的日期。MySql获取和显示这个类型的格式为“YYYY-MM-DD”.支持的时间范围“1000-00-00”到“9999-12-31”
 * 2.Datetime类型，存储既有日期又有时间的数据。存储和显示的格式为“YYYY-MM-DD HH:MM:SS”.支持的时间范围是“1000-00-00 00:00:00”到“9999-12-31 23:59:59”.
 * 3.Timestamp类型，也是存储既有日期又有时间的数据。存储格式和Datetime一样。支持的时间范围“1970-01-01 00:00:01”到“2038-01-19 03:14:07”
 */
public class DateDemo {
    public static void main(String[] args) throws ParseException {
        Date d1 = new Date();
        System.out.println(d1);
        long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);
        System.out.println("--------------------------------");
        /**
         * 格式化：从Date-->String
         * HH表示24小时制，hh表示12小时制
         */
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd 'T' HH:mm:ss");
        String s = sdf.format(d1);
        System.out.println(s);
        System.out.println("--------------------------------");
        /**
         * 解析：从String-->Date
         * 用SimpleDateFormat的parse()方法
         */
        String s1="2021年07月06日 12:12:12";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //这里的调用需要抛出异常,编译时异常
        Date d3 = sdf1.parse(s1);
        System.out.println(d3);
    }
}

运行截图

CalendarDemo.java

import java.util.Calendar;
public class CalendarDemo {
    public static void main(String[] args) {
        //获取日期类对象,getInstance()方法会返回一个Calendar对象。
        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+date+"日");
        System.out.println("输出三年前的今天：");
        c.add(Calendar.YEAR,-3);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH) + 1;
        date = c.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+date+"日");
    }
}

运行截图

ExceptionDemo.java

import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        try {
            method1();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("结束");
    }
    private static void method1() throws Exception{
        String s = "2021-07-07";
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd");
        //编译时异常，此处使用throws 抛出，谁调用谁处理（try...catch...），
        Date d = sdf.parse(s);
        System.out.println(d);
    }
    private static void method() {
        int[] arr ={1,2,3};
        try {
            //可能出现异常的代码，运行时异常，此处使用try...catch...处理
            System.out.println(arr[3]);
            //ArrayIndexOutOfBoundsException
            System.out.println("可以执行到这里吗");
        }catch (Exception e){
            //输出异常信息
            e.printStackTrace();
        }
    }

}

ScoreException.java

/**
 * 自定义异常类，只需要继承Exception类，并创建两个构造方法即可
 */
public class ScoreException extends Exception{
    public ScoreException() {
    }
    public ScoreException(String message) {
        super(message);
    }
}

Teacher.java

public class Teacher {
    public void checkScore(int score) throws ScoreException{
        if(score<0||score>100){
            //throw 抛出异常，将异常抛给自定义的异常类处理
            throw new ScoreException("您给的分数有误！");
        }else {
            System.out.println("成绩正常！");
        }
    }
}

ScoreExceptionDemo.java

public class ScoreExceptionDemo {
    public static void main(String[] args) throws ScoreException{
        int a=100;
        int b=101;
        Teacher t = new Teacher();
        t.checkScore(a);
        t.checkScore(b);
        //Exception in thread "main" ScoreException: 您给的分数有误！
        // at Teacher.checkScore(Teacher.java:5)
        // at ScoreExceptionDemo.main(ScoreExceptionDemo.java:7)
    }
}

运行截图

CollectionDemo.java

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo {
    public static void main(String[] args) {
        //Collection集合不能够直接实例化，要通过子类进行实例化（多态的形式，向上转型）
        Collection<String> c = new ArrayList<String>();
        //常用方法,add()添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c);
        //输出集合对象  [hello, world, java]
        System.out.println("-------------------");
        //迭代器，通过Collection的iterator()方法创建
        Iterator<String> it = c.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
//            System.out.println(it.hasNext());
            //输出 true 或 false
        }
        System.out.println("-------------------");
        c.remove("world");
        System.out.println(c);
        //输出 [hello, java]
        //返回集合的长度
        int size = c.size();
        System.out.println(size);
        //输出 2
        //contains()方法用来判断集合中是否存在指定的元素
        boolean b = c.contains("hello");
        System.out.println(b);
        //输出 true
        c.clear();
        System.out.println(c);
        //输出  []
        //isEmpty()判断集合是否为空
        boolean empty = c.isEmpty();
        System.out.println(empty);
        //输出 true
        System.out.println("-------------------");
        /**
         * 创建集合，存储Student对象的集合，通过迭代器的方式，获取对象的属性值
         */
        Collection<Student> c1 = new ArrayList<Student>();
        Student s1 = new Student("leijun",36);
        Student s2 = new Student("leijun",36);
        Student s3 = new Student("mayun",39);
        c1.add(s1);
        c1.add(s2);
        c1.add(s3);
        System.out.println(c1);
        //输出  [Student@1b6d3586, Student@4554617c, Student@74a14482]
        Iterator<Student> it1 = c1.iterator();
        while (it1.hasNext()){
            Student s = it1.next();
            System.out.println("name:"+s.getName()+" "+"age:"+s.getAge());
        }
    }
}

运行截图

ListDemo.java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
 * List集合存储的元素是有序的，元素可以重复，有索引，当需要频繁的插入、删除、修改功能时，优先采用list集合
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);
        // 输出  [hello, hello, world, java]
        //遍历集合，得到每一个元素，如果有“world”这个元素，我就添加一个“javaee”的元素
        //1.使用迭代器遍历集合，
//        Iterator<String> it = list.iterator();
//        while (it.hasNext()){
//            String s = it.next();
//            if (s.equals("world")){
//                list.add("javaee");
//            }
//        }
//        System.out.println(list);
        //ConcurrentModificationException 当前修改异常（使用迭代器修改，会出现并发修改异常，解决方案是使用for循环遍历实现修改）
        //2.for循环遍历实现集合修改
        for (int i =0;i<list.size();i++){
            String s = list.get(i);
            if (s.equals("world")){
                list.add("javaee");
            }
        }
        System.out.println(list);
        //增强for循环实现，内部原理是一个Iterator迭代器
//        for (String s : list){
//            if (s.equals("world")){
//                list.add("javaee");
//            }
//        }
//        System.out.println(list);
        //ConcurrentModificationException
        System.out.println("---------------------------------");
        String re = list.remove(0);
        System.out.println(re);
        //移除指定索引处的元素,并返回移除的元素值
        String set = list.set(0, "hi");
        //修改指定索引处的元素值，并返回被修改的元素值
        System.out.println(set);
        String ge = list.get(0);
        //获取指定元素的值
        System.out.println(ge);
        System.out.println(list);
        System.out.println("---------------------------------");
        List<Student> li = new ArrayList<Student>();
        Student s1 = new Student("leijun",36);
        Student s2 = new Student("leijun",36);
        Student s3 = new Student("mayun",39);
        li.add(s1);
        li.add(s2);
        li.add(s3);
        //通过迭代器进行遍历
        Iterator<Student> it1 = li.iterator();
        while (it1.hasNext()){
            Student s = it1.next();
            System.out.println("name:"+s.getName()+" "+"age:"+s.getAge());
        }
        System.out.println("---------------------------------");
        //通过for循环进行遍历
        for (int i =0;i<li.size();i++){
            Student s = li.get(i);
            System.out.println("name:"+s.getName()+" "+"age:"+s.getAge());
        }
        System.out.println("---------------------------------");
        //增强for循环遍历,格式for(元素数据类型  变量名：数组/集合对象名){ 循环体 }
        for(Student s:li){
            System.out.println("name:"+s.getName()+" "+"age:"+s.getAge());
        }
    }
}

运行截图

SetDemo.java

import java.util.HashSet;
import java.util.Set;
/**
 * 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(String s : set){
            System.out.println(s);
        }
        //输出 ：
        //world
        //java
        //hello
        //创建HashSet集合对象
        HashSet<String> hs = new HashSet<String>();
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        for (String s:hs){
            System.out.println(s);
        }
        /**
         * 存储无序，元素唯一
         */
        HashSet<EqualsObject> hs1 = new HashSet<EqualsObject>();
        //创建三个对象，如果对象属性值相同，我们就认为是同一个对象，这时就需要在对象类中重写equals方法
        EqualsObject eo1 =new EqualsObject("雷军",36);
        EqualsObject eo2 =new EqualsObject("雷军",36);
        EqualsObject eo3 =new EqualsObject("马云",36);
        hs1.add(eo1);
        hs1.add(eo2);
        hs1.add(eo3);
        for (EqualsObject eo:hs1){
            System.out.println("name:"+eo.getName()+" "+"age:"+eo.getAge());
        }
    }
}

运行截图

TreeSetDemo.java

import java.util.Comparator;
import java.util.TreeSet;
/**
 * TreeSet集合，元素有序，可以按照一定的规则进行排序，具体的排序方式取决于构造方法
 * TreeSet():根据其元素的自然排序进行排序
 * TreeSet(Comparator comparator):根据指定的比较器进行排序
 * 自然排序：就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<Student2> ts = new TreeSet<>(new Comparator<Student2>() {
            @Override
            public int compare(Student2 o1, Student2 o2) {
                //主要条件，先按年龄排序
                int num =o1.getAge()-o2.getAge();
                //次要条件，年龄相等，按姓名字母进行排序
                int num1 = num==0?o1.getName().compareTo(o2.getName()):num;
                return num1;
            }
        });
        Student2 s1 = new Student2(2,"雷军",36);
        Student2 s2 = new Student2(2,"雷军",36);
        Student2 s3 = new Student2(1,"马云",45);
        Student2 s4 = new Student2(3,"刘星",29);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        for (Student2 s:ts){
            System.out.println("sid:"+s.getSid()+" "+"name:"+s.getName()+" "+"age:"+s.getAge());
        }
    }
}

运行截图

ArgsDemo.java

public class ArgsDemo {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40,50));
        System.out.println(sum(10,20,30,40,50,60,70,80,90));
    }
    /**
     * 可变参数，这里的变量其实是一个数组，如果一个方法有多个参数，包含可变参数，可变参数要放在最后
     * @param a
     * @return
     */
    public static int sum(int... a){
        int sum = 0;
        for(int i:a){
            sum+=i;
        }
        return sum;
    }
}

运行截图

MapDemo.java

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
 * Map集合存储无序，键值不允许重复，值可以重复
 */
public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String, String>();
        map.put("it001","雷军");
        map.put("it003","马云");
        map.put("it002","马云");
        map.put("it002","雷军");
        System.out.println(map);
        System.out.println(map.size());
        //根据键值，返回对应的值
        System.out.println(map.get("it001"));
        //获取所有键的集合
        Set<String> keyS = map.keySet();
        for (String key :keyS){
            System.out.println(key);
        }
        //获取所有值的集合
        Collection<String> values = map.values();
        for (String value:values){
            System.out.println(value);
        }
        //遍历方式一：先获取所有键值的集合，然后再根据键值找对应的值
        Set<String> key = map.keySet();
        for (String skey:key){
            String valu = map.get(skey);
            System.out.println("key:"+skey+" "+"value:"+valu);
        }
        //遍历方式二：用entrySet()方法获取所有键值对的集合，遍历键值对对象集合，根据getKey()和getValue()获取键值和值
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for(Map.Entry<String, String> me:entries){
            String key1 = me.getKey();
            String value = me.getValue();
            System.out.println("key:"+key1+" "+"value:"+value);
        }
        map.remove("it002");
        System.out.println(map);
        boolean iskey = map.containsKey("it001");
        boolean isValue = map.containsValue("雷军");
        System.out.println(iskey);
        System.out.println(isValue);
        map.clear();
        boolean empty = map.isEmpty();
        System.out.println(empty);
        System.out.println(map);

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

运行截图

HashMapDemo.java

import java.util.HashMap;
import java.util.Set;
/**
 * 键值不允许重复
 */
public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<EqualsObject,String> hm = new HashMap<EqualsObject,String>();
        EqualsObject eo1=new EqualsObject("雷军",36);
        EqualsObject eo2=new EqualsObject("雷军",36);
        EqualsObject eo3=new EqualsObject("马云",32);
        EqualsObject eo4=new EqualsObject("刘星",29);
        hm.put(eo1,"北京");
        hm.put(eo2,"北京");
        hm.put(eo3,"杭州");
        hm.put(eo4,"北京");
        Set<EqualsObject> keys = hm.keySet();
        for (EqualsObject eo:keys){
            String value = hm.get(eo);
            System.out.println("name:"+eo.getName()+" "+"age:"+eo.getAge()+" "+value);
        }
        System.out.println("--------------------------------------------------------");
        HashMap<String, EqualsObject> hm1 = new HashMap<String, EqualsObject>();
        hm1.put("北京",eo1);
        hm1.put("北京",eo2);
        hm1.put("杭州",eo3);
        hm1.put("北京",eo4);
        Set<String> keys1 = hm1.keySet();
        for (String key:keys1){
            EqualsObject eovalue = hm1.get(key);
            System.out.println(key+" "+"name:"+eovalue.getName()+" "+"age:"+eovalue.getAge());
        }
    }
}

运行截图

FileDemo.java

import java.io.File;
import java.io.FileOutputStream;
/**
 * file是文件和目录路径名的抽象表示，它可以将文件和目录封装成对象
 */
public class FileDemo {
    public static void main(String[] args) throws Exception{
        //通过给定的路径名的字符串转换为抽象路径名，来创建新的File实例
        File f1 = new File("D:\\itfile\\java.txt");
        System.out.println(f1);
        //从父路径名字符串和子路径名字符串，创建新的File实例
        File f2 = new File("D:\\itfile", "java.txt");
        System.out.println(f2);
        //从父抽象路径名和子路径名字符串创建新的File实例
        File f3 = new File("D:\\itfile");
        File f4 = new File(f3, "java.txt");
        System.out.println(f4);
        //测试此抽象路径名表示的File是否存在
        boolean exists = f1.exists();
        System.out.println(exists);
        //测试此抽象路径名是否为目录
        boolean directory = f1.isDirectory();
        System.out.println(directory);
        //测试此抽象路径名是否为文件
        boolean file = f1.isFile();
        System.out.println(file);
        if (!exists){
            f1.createNewFile();
            System.out.println("该文件不存在，已为您创建成功！");
        }
        System.out.println(f1.getAbsolutePath());
        // 输出 D:\itfile\java.txt
        System.out.println(f1.getPath());
        //将此抽象路径名转换为字符串
        System.out.println(f1.getName());
        //输出 java.txt  返回此抽象路径名表示的文件或目录的名称
        System.out.println("------------------------");
        //返回目录中的 文件和目录 的名称字符串数组
        String[] strArray = f3.list();
        for (String str : strArray){
            System.out.println(str);
            // 输出  java.txt
        }
        //返回目录中的 文件和目录 的File对象数组
        File[] fileArray = f3.listFiles();
        for (File file1:fileArray){
            System.out.println(file1);
            //输出 D:\itfile\java.txt
        }
        File f5 = new File("D:\\Workspace\\demo\\itFile");
        if(!f5.exists()){
            boolean mkdir = f5.mkdir();
            System.out.println("是否创建成功"+mkdir);
        }
        boolean directory1 = f5.isDirectory();
        System.out.println("该路径表示的是否为目录"+directory1);
        boolean delete = f5.delete();
        System.out.println("是否删除成功"+delete);
    }
}

运行截图

DiGUIDemo.java

import java.io.File;
public class DiGuiDemo {
    public static void main(String[] args) {
        //根据指定的路径，创建一个File对象
        File srcFile = new File("D:\\itfile");
        //调用方法
        getAllFilePath(srcFile);
    }
    private static void getAllFilePath(File srcFile) {
        //获取目录下所有的文件或目录的File对象数组
        File[] fileArray = srcFile.listFiles();
        for (File file:fileArray){
            if (file.isDirectory()){
                getAllFilePath(file);
            }else {
                System.out.println(file.getAbsolutePath());
            }
        }
    }
}

运行截图

FileOutputStreamDemo.java

import java.io.File;
import java.io.FileOutputStream;
/**
 * 字节输出流写数据
 */
public class FileOutputStreamDemo {
    public static void main(String[] args) throws Exception{
        //创建字节输出流，并指向文件
        FileOutputStream fos = new FileOutputStream("D:\\itfile\\java01.txt");
        /*
        这里做了三件事：
        1.调用系统功能创建了文件
        2.创建了字节输出流对象
        3.让字节输出流对象指向创建号的文件
         */
        fos.write(97);
        //一次写入一个字节数组的内容，方式一
        byte[] bys = {97,98,99,100,101};
        fos.write(bys);
        //方式二,getByte()
        byte[] bys1 = "abcde".getBytes();
        /*
        追加输入：要实现换行
        Windows：\r\n
        linux:\n
        mac:\r
         */
        for (int i=0;i<10;i++){
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }
        fos.close();
    }
}

运行截图

FileInputStreamDemo.java

import java.io.FileInputStream;
/*
字节输入流读数据
 */
public class FileInputStreamDemo {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("D:\\itfile\\java01.txt");
        int by;
        /*
        当读取到值为 -1 的时候，表示已读完数据
         */
        //一次读取一个字节
//        while ((by=fis.read())!=-1){
//            System.out.print((char)by);
//        }
        System.out.println("--------------------------");
        //一次读取一个字节数组
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1){
            System.out.print(new String(bys,0,len));
        }
        fis.close();
    }
}

运行截图

CopyDemo.java

import java.io.FileInputStream;
import java.io.FileOutputStream;
public class CopyDemo {
    public static void main(String[] args) throws Exception{
        /*
        字节流复制文件
         */
        //创建数据源对象
        FileInputStream fis1 = new FileInputStream("D:\\itfile\\java.txt");
        //创建目的地对象
        FileOutputStream fos1 = new FileOutputStream("D:\\Workspace\\demo\\java.txt");
        //读写数据，一次读取一个字节，一次写入一个字节
        int by;
        while ((by=fis1.read())!=-1){
            fos1.write(by);
        }
        //释放资源
        fis1.close();
        fos1.close();
        /*
        字节流复制图片
         */
        FileInputStream fis2 = new FileInputStream("D:\\itfile\\hk.jpg");
        FileOutputStream fos2 = new FileOutputStream("D:\\Workspace\\demo\\hk.jpg");
        //一次读取一个字节数组，一次写入一个字节数组
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis2.read(bys))!=-1){
            fos2.write(bys,0,len);
        }
        fis2.close();
        fos2.close();
    }
}

运行截图

StringDemo2.java

import javax.xml.soap.SOAPMessage;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
public class StringDemo2 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        /*
        字符串中的编码解码问题
         */
        //根据指定编码规则进行编码
        String s = "中国";
        byte[] bys1 = s.getBytes("UTF-8");
        // 输出  [-28, -72, -83, -27, -101, -67]
        System.out.println(Arrays.toString(bys1));
        byte[] bys = s.getBytes("GBK");
        System.out.println(Arrays.toString(bys));
        //输出  [-42, -48, -71, -6]
        //解码
        String s1 = new String(bys1,"UTF-8");
        System.out.println(s1);
        String s2 = new String(bys,"GBK");
        System.out.println(s2);
    }
}

运行截图

ConversionStreamDemo.java

import java.io.*;
public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        //数据源
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\itfile\\java.txt"),"GBK");
        osw.write("中国");
        osw.close();
        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\itfile\\java.txt"), "GBK");
//        int ch;
//        while ((ch=isr.read())!=-1){
//            System.out.print((char)ch);
//        }
        char[] cha = new char[1024];
        int len;
        while ((len=isr.read(cha))!=-1){
            System.out.println(new String(cha,0,len));
        }
        isr.close();
    }
}

运行截图

CopyJavaDemo.java

import java.io.*;
/*
字符流
 */
public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源对象,字符输入流读数据
        InputStreamReader isr1 = new InputStreamReader(
                new FileInputStream("D:\\Workspace\\demo\\src\\main\\java\\ConversionStreamDemo.java"));
        //创建目的地对象，字符输出流写数据
        OutputStreamWriter osw1 = new OutputStreamWriter(
                new FileOutputStream("D:\\Workspace\\demo\\CopyJavaDemo.java"));
        //一次读一个字符，一次写一个字符
//        int ch;
//        while((ch=isr1.read())!=-1){
//            osw1.write((char)ch);
//        }
        //一次读一个字符数组，一次写一个字符数组
        char[] cha = new char[1024];
        int len;
        while ((len=isr1.read(cha))!=-1){
            osw1.write(cha,0,len);
        }
        isr1.close();
        osw1.close();
        /**
         * 复制Java文件升级版，使用便捷流对象
         */
        //创建数据源
        FileReader fr = new FileReader("D:\\Workspace\\demo\\src\\main\\java\\ConversionStreamDemo.java");
        //创建目的地
        FileWriter fw = new FileWriter("D:\\Workspace\\demo\\CopyJavaDemo01.java");
        //读写数据，一次读一个字符，一次写一个字符
//        int ch;
//        while ((ch=fr.read())!=-1){
//            fw.write((char)ch);
//        }
        //一次读一个字符数组的数据，一次写一个字符数组的数据
        char[] cha1 = new char[1024];
        int len1;
        while ((len1=fr.read(cha1))!=-1){
            fw.write(cha1,0,len1);
        }
        fr.close();
        fw.close();
    }
}

BufferedStreamDemo.java

import java.io.*;
/**
 * 字符缓冲流
 */
public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源，字符缓冲流
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\itfile\\java.txt"));
        //写数据
//        bw.write("java\r\n");
//        bw.write("java01\r\n");
//        bw.close();
        //创建目的地对象，字符缓冲流
        BufferedReader br = new BufferedReader(new FileReader("D:\\itfile\\java.txt"));
        //读数据,一次读一个字符数据
//        int ch;
//        while ((ch=br.read())!=-1){
//            System.out.print((char)ch);
//        }
        //一次读一个字符数组的数据
//        char[] cha = new char[1024];
//        int len;
//        while ((len=br.read(cha))!=-1){
//            System.out.println(new String(cha,0,len));
//        }
//        br.close();
        /**
         * 字符缓冲流特有功能
         * newLine() 写一行 行分隔符，行分隔符字符串由系统属性定义。
         * readLine() 读一行文字。结果包含 行的内容的字符串 ，不包括任何 行终止字符 如果流的结尾已经到达，则为null
         */
        //写数据
        for (int i =0;i<10;i++){
            bw.write("hello"+i);
            bw.newLine();
            bw.flush();
        }
        bw.close();
        //读数据
        String line;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }
        br.close();
        /**
         * 特有功能复制文件
         */
        BufferedReader br1 = new BufferedReader(new FileReader("D:\\Workspace\\demo\\src\\main\\java\\ConversionStreamDemo.java"));
        BufferedWriter bw1 = new BufferedWriter(new FileWriter("D:\\Workspace\\demo\\Copy.java"));
        String line1;
        while ((line1=br1.readLine())!=null){
            bw1.write(line1);
            bw1.newLine();
            bw1.flush();
        }
        bw1.close();
        br1.close();
    }
}

运行截图

TxtToArrayListDemo.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/**
 * 文件到数组，文件中的每一行，作为一个字符串存储为一个元素
 */
public class TxtToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源
        BufferedReader br = new BufferedReader(new FileReader("D:\\itfile\\java.txt"));
        //创建集合
        ArrayList<String> array = new ArrayList<String>();
        //读写数据，存储到集合中
        String line;
        while ((line=br.readLine())!=null){
            array.add(line);
        }
        br.close();
        //遍历集合
        for (String s:array){
            System.out.println(s);
        }
    }
}

运行截图

ArrayListToTxtDemo.java

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
/**
 * 数组到文件，数组的每一个元素作为一行，写入文件
 */
public class ArrayListToTxtDemo {
    public static void main(String[] args) throws IOException {
        //创建集合
        ArrayList<String> array = new ArrayList<String>();
        //添加元素
        for (int i=0;i<10;i++){
            array.add("world"+i);
        }
        //创建字符缓冲输出流对象,目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\itfile\\java.txt"));
        //遍历集合，写入文件
        for (String s:array){
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }
}

运行截图

CallNameDemo.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
/**
 * 点名器案例，从文件中随机选中一个名字
 */
public class CallNameDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源，字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("D:\\itfile\\java.txt"));
        //创建一个集合
        ArrayList<String> array = new ArrayList<String>();
        //读写数据，将文件中的数据，存入数组，文件中每一行一个名字
        String line;
        while ((line= br.readLine())!=null){
            array.add(line);
        }
        //创建随机数,生成[0,array.size]范围的随机数
        Random r =new Random();
        int index = r.nextInt(array.size());
        String s = array.get(index);
        System.out.println("本次幸运儿："+s);
    }
}

运行截图

BallDemo.java

import java.util.Scanner;
/**
 * 这是一个真实的笔试题
 * 5个球，用天平称重，其中有一个球或轻或重，已知a球为标准球，求出哪一个球是特殊球，天平只能用两次.
 */
public class BallDemo {
    public static void main(String[] args) {
//        int a=10;
//        int b=10;
//        int c=9;
//        int d=10;
//        int e=10;
//        System.out.println(b);
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入4个相等的值，和一个不相等的值：");
//        int i = sc.nextInt();
        int[] array = new int[5];
        for (int i= 0;i<array.length;i++){
            array[i]= sc.nextInt();
//            System.out.println(array[i]);
        }
        int a=array[0];
        int b=array[1];
        int c=array[2];
        int d=array[3];
        int e=array[4];
        if((a+b)==(c+d)){
            if(a>e){
                System.out.println("e is special:"+e+" "+"light");
            }else {
                System.out.println("e is special:"+e+" "+"weight");
            }
        }else if ((a+b)>(c+d)){
            if (c==d){
                System.out.println("b is special:"+b+" "+"weight");
            }else if (c>d){
                System.out.println("d is special:"+d+" "+"light");
            }else {
                System.out.println("c is special:"+c+" "+"light");
            }
        }else if ((a+b)<(c+d)){
            if (c==d){
                System.out.println("b is special:"+b+" "+"light");
            }else if (c>d){
                System.out.println("c is special:"+c+" "+"weight");
            }else {
                System.out.println("d is special:"+d+" "+"weight");
            }
        }
    }
}

运行截图

ArrayListToFileDemo.java

import java.io.*;
import java.util.ArrayList;
public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建集合
        ArrayList<Student2> array = new ArrayList<Student2>();
        //创建学生对象
        Student2 s1 = new Student2(1,"雷军",36);
        Student2 s2 = new Student2(2,"马云",39);
        //存储到集合
        array.add(s1);
        array.add(s2);
        for(Student2 s:array){
            System.out.println(s.getSid()+" "+s.getName()+" "+s.getAge());
        }
        //创建字符缓冲输出流，目的地
//        BufferedReader br = new BufferedReader(new FileReader("D:\\itfile\\java.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\itfile\\java.txt"));
        for (Student2 a1:array){
            //按指定字符串的格式写入，拼接
            StringBuilder sb = new StringBuilder();
            sb.append(a1.getSid()).append(",").append(a1.getName()).append(",").append(a1.getAge());
            String s = sb.toString();
            bw.write(s);
//            bw.write(a1.getSid()+" "+a1.getName()+" "+a1.getAge());
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }
}

运行截图

FileToArrayListDemo.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源对象，使用字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("D:\\itfile\\java.txt"));
        //创建集合对象
        ArrayList<Student2> array = new ArrayList<Student2>();
        //读写数据
        String line;
        while ((line= br.readLine())!=null){
            //将读到的数据按照指定的 分隔符 ，进行分割存储
            String[] strArray = line.split(",");
            //创建学生对象
            Student2 s1 = new Student2();
            s1.setSid(Integer.parseInt(strArray[0]));
            s1.setName(strArray[1]);
            s1.setAge(Integer.parseInt(strArray[2]));
            //将学生对象添加到集合
            array.add(s1);
        }
        //释放资源
        br.close();
        //遍历集合
        for (Student2 stu:array){
            System.out.println(stu.getSid()+" "+stu.getName()+" "+stu.getAge());
        }
    }
}

运行截图

CopyFolderDemo.java

import java.io.*;
/**
 * 复制单级文件夹
 */
public class CopyFolderDemo {
    public static void main(String[] args) throws IOException{
        //创建数据源对象，File
        File srcFolder = new File("D:\\itfile");
        String srcFolderName = srcFolder.getName();
        System.out.println("数据源文件夹名："+srcFolderName);
        //创建目的地对象
        File destFolder = new File("D:\\Workspace\\demo",srcFolderName);
        String destFolderName = destFolder.getName();
        System.out.println("目的地文件加名："+destFolderName);
        //判断目的地对象，是否存在该文件夹，不存在就创建
        if (!destFolder.exists()){
            destFolder.mkdir();
        }
        //获取数据源所有文件的File数组
        File[] listFiles = srcFolder.listFiles();
        //遍历File数组，获取每一个File对象，这里的File对象就是数据源文件
        for (File srcFile:listFiles){
            //获取文件名称
            String srcFileName = srcFile.getName();
            //创建目的地文件对象
            File destFile = new File(destFolder,srcFileName);
            //复制文件,这里通过方法实现
            copyFile(srcFile,destFile);
        }
    }
    private static void copyFile(File srcFile, File destFile) throws IOException {
        //这里选用字节缓冲流实现，首先创建字节缓冲输入流，获取数据源文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        //创建字节缓冲输出流，创建目的地对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
        //读写数据,一次读写一个字节
//        int by;
//        while ((by=bis.read())!=-1){
//            bos.write(by);
//            bos.flush();
//        }
        //一次读写一个字节数组
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read())!=-1){
            bos.write(bys,0,len);
            bos.flush();
        }
        bis.close();
        bos.close();
    }
}

CopyFileDemo.java

import java.io.*;
/**
 * 复制多级文件
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException{
        //创建数据源文件对象
        File srcFile = new File("D:\\itfile");
        //创建目的地文件对象
        File destFile = new File("D:\\Workspace\\demo");
        copyFolder(srcFile,destFile);
    }
    private static void copyFolder(File srcFile, File destFile) throws IOException{
        //判断数据源是否为目录
        if (srcFile.isDirectory()){
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile,srcFileName);
            if (!newFolder.exists()){
                newFolder.mkdir();
            }
            //获取数据源所有文件的File数组
            File[] listFiles = srcFile.listFiles();
            //遍历数组，获取每一个File对象
            for (File file:listFiles){
                copyFolder(file,newFolder);
            }
        }else {
            //直接复制，使用字节流,目的地文件名+数据源文件名
            File newFile = new File(destFile,srcFile.getName());
            copyFile(srcFile,newFile);
        }
    }
    private static void copyFile(File srcFile, File newFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));
        byte[] bys = new byte[1024];
        int len;
        while ((len= bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }
        bis.close();
        bos.close();
    }
}

PrintStreamDemo.java

import java.io.IOException;
import java.io.PrintStream;
/**
 * 字节打印流
 */
public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节打印流
        PrintStream ps = new PrintStream("D:\\itfile\\java.txt");
        //写数据
        //字节输出流有的方法
//        ps.write(97);
//        ps.write(98);
//        ps.write(99);
        //字节流特有的方法
        ps.print(97);
        ps.println(98);
        ps.println(99);
        ps.close();
    }
}

PrintWriterDemo.java

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
 * 字符打印流，是不可以直接写入文件的，需要执行刷新操作
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException  {
      //创建字符打印流,使用指定的文件名，创建一个新的PrintWriter,而不需要执行自动刷新操作
//        PrintWriter pw = new PrintWriter("D:\\itfile\\java.txt");
//        pw.write("hello");
//        pw.write("\r\n");
//        pw.flush();
//        pw.write("world");
//        pw.write("\r\n");
//        pw.flush();
//        pw.println(99);
//        pw.flush();
//        pw.println(100);
//        pw.flush();
//        pw.close();
        //使用指定的文件名，创建一个新的PrintWriter,设置为true可以自动执行 行刷新，自动写入文件。
        PrintWriter pw = new PrintWriter(new FileWriter("D:\\itfile\\java.txt"),true);
//        PrintWriter pw = new PrintWriter(new FileWriter("D:\\itfile\\java.txt"),false);
//        pw.write("hello");
//        pw.write("\r\n");
//        pw.flush();
        pw.println("hello");
        pw.println("world");
        pw.close();
    }
}

CopyJavaDemo1.java

import java.io.*;
/**
 * 使用Java文件打印流复制文件（改进版）
 */
public class CopyJavaDemo1 {
    public static void main(String[] args) throws IOException {
        //创建数据源对象，这里采用字符缓冲流
        BufferedReader br = new BufferedReader(new FileReader("D:\\Workspace\\demo\\src\\main\\java\\CopyJavaDemo.java"));
        //创建目的地对象，使用字符打印流
        PrintWriter pw = new PrintWriter(new FileWriter("D:\\Workspace\\demo\\CopyJavaDemo.java"),true);
        //读写数据
        String line;
        while ((line= br.readLine())!=null){
            pw.println(line);
        }
        //释放资源
        br.close();
        pw.close();
    }
}

Student3.java

import java.io.Serializable;
/**
 * 对象序列化，就是将对象保存到磁盘中，或者在网络中传输对象，用一个字节序列来表示一个对象（包括对象名，属性）
 * 字节序列写到文件之后，相当于文件中持久保存了一个对象信息，将这些信息从文件中读取出来，重构对象，就是反序列化
 * 一个对象要想被序列化，那么该对象所属的类，就要实现Serializable接口，不需要重写任何方法
 */
public class Student3 implements Serializable {
    //如果一个对象序列化后，我们修改了对象所属的类文件，读取文件会抛出 InvalidClassException 异常，
    // 解决方法：给所属类加一个serialVersionUID
//    private static final long serialVersionUID=42L;
    private String name;
    private int age;
    //如果某个属性值不想被序列化，则加 transient 关键字进行修饰
//    private transient int age;
    public Student3() {
    }
    public Student3(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 String toString() {
        return "Student3{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

ObjectOutputStreamDemo.java

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
 * 序列化
 */
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\itfile\\java.txt"));
        //创建需要序列化的对象
        Student3 s = new Student3("雷军",36);
        oos.writeObject(s);
        oos.close();
    }
}

ObjectIntputStreamDemo.java

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
 * 反序列化读数据
 */
public class ObjectIntputStreamDemo {
    public static void main(String[] args) throws IOException,ClassNotFoundException{
        //创建反序列化对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\itfile\\java.txt"));
        //读取一个对象
        Object obj = ois.readObject();
        Student3 s = (Student3) obj;
        System.out.println(s.getName()+","+s.getAge());
        ois.close();
    }
}

运行截图

PropertiesDemo.java

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
/**
 * 可以作为Map集合使用，存储 键、值 都是字符串
 */
public class PropertiesDemo {
    public static void main(String[] args) throws IOException{
        //把集合中的数据保存到文件，写方法实现
//        myStore();
        //把文件中的数据加载到集合
        myLoad();

    }
    private static void myLoad() throws IOException{
        //创建properties集合
        Properties prop = new Properties();
        //创建数据源对象，使用便捷输入流
        FileReader fr = new FileReader("D:\\itfile\\java.txt");
        //加载数据到集合中
        prop.load(fr);
        System.out.println(prop);
        //遍历
        Set<String> names = prop.stringPropertyNames();
        for (String key:names){
            Object value = prop.get(key);
            System.out.println(key+","+value);
        }
    }
    private static void myStore() throws IOException {
        //创建properties集合
        Properties prop = new Properties();
        //添加数据
        prop.setProperty("it001","雷军");
        //键值不允许重复
        prop.setProperty("it002","马云");
        prop.setProperty("it002","马云");
        prop.setProperty("it003","马云");
        //创建目的地对象，采用便捷输出流对象创建
        FileWriter fw = new FileWriter("D:\\itfile\\java.txt");
        //将集合数据保存到文件
        prop.store(fw,null);
        fw.close();
    }
}

运行截图

GuessNumber.java

import java.util.Random;
import java.util.Scanner;
public class GuessNumber {
    public GuessNumber() {
    }
    public static void start(){
        System.out.println("欢迎试玩猜数字小游戏!");
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        int count=1;
        while (true){
            System.out.println("现在已生成数字，请输入你猜的数字(1-100)：");
            Scanner sc = new Scanner(System.in);
            int i = sc.nextInt();
            if(i>number){
                System.out.println("你猜的数字大了");
                count++;
            }else if(i<number){
                System.out.println("你猜的数字小了");
                count++;
            }else {
                System.out.println("恭喜你猜对了！一共猜了"+count+"次！");
                break;
            }
        }
    }
}

PropertiesDemo1.java

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
 * 猜数字小游戏，只能玩三次，次数存在文件里
 */
public class PropertiesDemo1 {
    public static void main(String[] args) throws IOException {
        //创建集合
        Properties prop = new Properties();
        //创建数据源对象
        FileReader fr = new FileReader("D:\\itfile\\java.txt");
        //载入集合
        prop.load(fr);
        fr.close();
        //获取字符串count
        String count = prop.getProperty("count");
        int number = Integer.parseInt(count);
        System.out.println(number);
        //判断次数
        if(number>=3){
            System.out.println("游戏试玩结束！");
        }else {
            GuessNumber.start();
            number++;
            //存入集合
            prop.setProperty("count",String.valueOf(number));
            //创建目的地对象
            FileWriter fw = new FileWriter("D:\\itfile\\java.txt");
            //存入文件
            prop.store(fw,null);
            fw.close();
        }
    }
}

运行截图

MyThread.java

/**
 * 创建线程类必须要继承Thread类，并重写run()方法（相当于普通方法调用）
 */
public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run(){
        System.out.println("重写run方法");
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

MyThreadDemo.java

public class MyThreadDemo {
    public static void main(String[] args) {
        //创建线程
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        MyThread mt3 = new MyThread();
//        mt1.run();
//        mt2.run();

        mt1.setName("高铁");
        mt2.setName("飞机");
        mt3.setName("汽车");

        //默认优先级 5
        System.out.println(mt1.getPriority());
        System.out.println(mt2.getPriority());
        System.out.println(mt3.getPriority());

        //线程优先级最大为10，最小为1，默认为5
        System.out.println(Thread.MAX_PRIORITY);
        System.out.println(Thread.MIN_PRIORITY);
        System.out.println(Thread.NORM_PRIORITY);

        mt1.setPriority(5);
        mt2.setPriority(10);
        mt3.setPriority(1);

        //此线程开始执行；Java虚拟机调用此线程的run()方法
        mt1.start();
        mt2.start();
        mt3.start();

        //返回当前正在执行的线程对象的引用、、返回一个引用当前正在执行的 线程的 对象
        System.out.println(Thread.currentThread().getName());
    }
}

ThreadSleep.java

/**
 * 线程控制方法：
 * sleep()  使当前正在执行的线程停留指定的毫秒数
 * join()  等待这个线程死亡
 * setDaemon()  设置为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
 */
public class ThreadSleep extends Thread{
    public ThreadSleep() {
    }
    @Override
    public void run(){
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

ThreadSleepDemo.java

public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();
        ts1.setName("刘备");
        ts2.setName("关羽");
        ts3.setName("张飞");
        ts1.start();
        ts2.start();
        ts3.start();
    }
}

ThreadJoin.java

public class ThreadJoin extends Thread{
    @Override
    public void run(){
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

ThreadJoinDemo.java

public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1= new ThreadJoin();
        ThreadJoin tj2= new ThreadJoin();
        ThreadJoin tj3= new ThreadJoin();
        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");
        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}

ThreadDeamon.java

/**
 * 守护线程
 */
public class ThreadDeamon extends Thread{
    @Override
    public void run(){
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

ThreadDeamonDemo.java

public class ThreadDeamonDemo {
    public static void main(String[] args) {
        ThreadDeamon td1 = new ThreadDeamon();
        ThreadDeamon td2 = new ThreadDeamon();
        td1.setName("关羽");
        td2.setName("张飞");
        //设置主线程
        Thread.currentThread().setName("刘备");
        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);
        td1.start();
        td2.start();
        for (int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

MyRunnable.java

/**
 * 创建线程的两种方式：
 * 1.继承Thread
 * 2.实现Runnable接口
 * 实现接口的好处：
 * 避免了Java单继承的局限性，适合多个代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离。体现了面向对象的设计思想
 */
public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for (int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

MyRunnableDemo.java

public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建实现类对象
        MyRunnable mr = new MyRunnable();
        //创建线程
        Thread t1 = new Thread(mr,"飞机");
        Thread t2 = new Thread(mr,"高铁");

        t1.start();
        t2.start();
    }
}

ShellTicket.java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SellTicket implements Runnable{
    private int tickets = 100;
//    private static int tickets = 100;
    //无同步锁
//    @Override
//    public void run(){
//        while (true){
    //设置为死循环的原因是，票买完后，还是会有人来窗口问
//            if(tickets>0){
//                System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
//                tickets--;
//            }
//        }
//    }
    //加同步锁,新建一个任意对象
//    private Object obj = new Object();
//    @Override
//    public void run(){
//
//        while (true){
//            synchronized (obj){
//                //t1进来后，就会把这段代码给锁起来
//                if(tickets>0){
//                    try {
//                        Thread.sleep(100);
//                        //休息100毫秒
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
//                    tickets--;
//                }
//            }
//            //t1出来，代码块解锁
//        }
//
//    }
    /**
     * 同步方法和同步静态方法
     */
    //同步方法
//    @Override
//    public void run(){
//        while (true){
//            sellTicket();
//        }
//    }
//
//    private static synchronized void sellTicket() {
//        if(tickets>0){
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
//            tickets--;
//        }
//    }
//    private synchronized void sellTicket() {
//        if(tickets>0){
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
//            tickets--;
//        }
//    }
    /**
     * Lock锁，是一个接口，一般使用它的实现类ReentrantLock来实例化（多态）
     * 可以看到在哪里加了锁，在哪里释放了锁
     */
    private Lock lock = new ReentrantLock();
    @Override
    public void run(){
        while (true){
            //加锁，后面必须跟try...finally...第一条语句必须是unlock()
            lock.lock();
            try {
                if (tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                    tickets--;
                }
            }finally {
                //释放锁
                lock.unlock();
            }
        }
    }
}

SellTicketDemo.java

/**
 * 由于线程执行的随机性，导致出现了多个窗口卖同一张票，或是出现复数票
 * 解决方案：同步代码块，就是给共享数据加锁。缺点是耗费资源，降低程序的运行效率
 * 第一种格式：synchronized(先建一个任意对象){ 多条语句操作共享数据的代码 }
 * 第二种格式：修饰符 synchronized 返回值类型 方法名（）{ 方法体 }，同步方法，同步方法的锁对象是this。同步静态方法的锁对象是 类名.class
 */
public class SellTicketDemo {
    public static void main(String[] args) {
        //创建接口实现类对象
        SellTicket st = new SellTicket();
        //创建线程对象
        Thread t1 = new Thread(st,"1号窗口");
        Thread t2 = new Thread(st,"2号窗口");
        Thread t3 = new Thread(st,"3号窗口");
        t1.start();
        t2.start();
        t3.start();
    }
}

SendDemo.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
 * UDP发送数据步骤:
 * 创建发送端的Socket对象，（ DatagramSocket ）
 * 创建数据，并把数据打包
 * 调用DatagramSocket对象方法发送数据
 * 关闭发送端
 */
public class SendDemo {
    public static void main(String[] args) throws IOException {
//        DatagramSocket ds = new DatagramSocket();
//        byte[] bys = "hello world".getBytes();
//        //将数据打包，并绑定主机地址和端口号
//        DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.222.1"),12345);
//        //发送数据
//        ds.send(dp);
//        //关闭发送端
//        ds.close();
        /**
         * 数据来自键盘输入，直到输入的数据是886，发送数据结束
         * UDP接收数据：因为不知道发送端什么时候停止发送，故采用死循环接收
         */
        //创建DatagramSocket对象
        DatagramSocket ds = new DatagramSocket();
        //自己封装来自键盘的录入数据,采用字符缓冲输入流，创建数据源
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //遍历获取每一个元素
        String line;
        while ((line=br.readLine())!=null){
            //判断是否为886
            if ("886".equals(line)){
                break;
            }
            //创建数据包，并打包
            byte[] bys = line.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length,InetAddress.getByName("192.168.222.1"),12345);
            //发送数据
            ds.send(dp);
        }
        ds.close();
        br.close();
    }
}

ReceiveDemo.java

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * UDP接受数据步骤：
 * 创建接收端的Socket对象（DatagramSocket）
 * 创建一个数据包，用于接收数据
 * 调用DatagramSocket对象的方法接受数据
 * 解析数据包，并把数据在控制台显示
 * 关闭接收端
 */
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //并指定端口号
        DatagramSocket ds = new DatagramSocket(12345);
        //因为接收端不知道发送端什么时候停止发送,所以通过死循环，实现一直接收
        while (true){
            //创建一个数据包，用来接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);
            //接收数据
            ds.receive(dp);
            //解析数据
            System.out.println("数据是："+ new String(dp.getData(),0, dp.getLength()));
        }
    }
}

运行截图