Java第十章

一.Object类
Object类是Java中所有类的父类，所以Object下的方法同时也是所有类的共有方法，
即使是你自定义的一个类，也拥有Object的方法。
所以需要掌握Object类下的常见方法：
1.equals方法
    a.equals(b);//其中a和b都要是一个对象而非一个基本数据类型或一个类。
    含义：判断两个对象是否为同一个对象(内存地址是否相等，本质就是==)，返回一个boolean值。
    凡是new出来的不可能是同一个对象。
    
    
2.toString方法    
    
public static void main(String[] args) {
    Student s1 = new Student(1, "张三", 12);
    Student s2 = new Student(1, "张三", 12);
    boolean b = s1.equals(s2);
    System.out.println(b);
    //注意上述s1和s2即使每个属性值都一样，但是依然返回false，原因就是都是new出来的。
    //注意：如果需要在某些特定场景，equals不是判断内存地址，而是判断id如何实现。    
    }

二.常见面试题：==和equals的区别
答案1：==如果作用于基本数据类型。就判断值是否相等。
答案2：==如果作用于引用数据类型，就判断地址是否相等
String str1 =  new String("你好")  ;
String str2 =  new String("你好")  ;
System.out.println( str1  ==  str2);//false
System.out.println( 1  ==  1);//true

String str1 = "你好";
String str2 = "你好";
System.out.println( str1  ==  str2);true
意味着str1和str2的地址是一样的。
总结：String声明变量的区别：
String str = new String("xx");
不管xx是什么，都要重新开辟一个新的内存。
String str = xx ;
如果xx存在了就不去开辟了 而是直接引用已经存在的，

答案3：equals:只能作用于引用数据类型，本质就是==
答案3：但是大部分的类都重写了equasl方法，例如String  ，Date
答案3：重写之后的equals则是判断值是否相等 
 
String str1 = "你好";
String str2 = "你好";
System.out.println( str1.equals(str2) );//true 错误的解释：因为str1和str2都是直接声明的所有地址相等

String str1 =  new String("你好") ;
String str2 = "你好";
System.out.println( str1.equals(str2) );//true 原因：String 也重写了equals方法,是判断值是否相等
而非地址

public static void main(String[] args) {
        
Object常见方法 ： toString
总结0：直接打印对象，和打印对象的.toString方法 效果是一样的 一般都是省略
总结1：Object的toString打印：对象的内存地址，格式：  路径+ @ + 内存地址

如果存在某个场合，希望打印的是具体属性信息而非地址，则可以通过重写toString方法实现。
大部分的实体类都会重写toString，原因：方便阅读实体对象是否符合要求    
                        
    Student s = new Student(1, "张三", 18);
    System.out.println(s.toString());
    System.out.println(s);
            
    }

三.String
1.易错点：String不是八大基本数据类型
但是String是Java中最常见的数据类型。可以存储字符串类型。
数据中包含数字，字母，符号等 都可以使用String声明
声明方式如下：
1.String str = “你好呀”;//直接声明，最常见
2.String str = new String(“你好呀”);//通过构造方法new实例化声明，了解即可
注意：null和空字符串的区别
String str = null;  //没有任何属性和方法的
String str = "null";//正常的字符串
String str = "";    //正常的字符串  只是长度为0罢了

2.通过String分别演示字符串的增删改查。
例如字符串为：“123abc”
要求：
将1修改成你
将2删除
在ab的中间添加~
将修改后的字符串输出在控制台上，

    String str = "123abc";
    str = str.replace("1", "你");
    str = str.replace("2", "");
    str = str.replace("ab", "a~b");
    System.out.println(str);

3.String的补充：
String被final修饰，意为最终类，无法被继承，也无法被修改。
我们声明的字符串其实本质上都是被final修饰的常量。
那么为什么可以随意修改呢？
本质上并不是修改，而是直接丢弃原本的字符串，去声明一个新的字符串。
所以如果某个字符串需要经常被修改，那么不推荐通过String声明，因为会产生大量的垃圾。（但是JVM自动回收，所以也可以用，但是不推荐。）
而是通过StringBuffer声明。所以String几乎没有提供修改的相关方法，都是通过重新声明实现。
    String str = "111";
    System.out.println(str);
    str = "222";
    System.out.println(str);

四.常见方法
Java中的String没有属性只有方法。备注：JavaScript的String既有属性也有方法。
常见方法如下：
int length();返回字符串的长度。
char charAt(int index);返回字符串中第几个字符，从0开始，注意下标溢出
int indexOf(String str);返回str首次出现的位置,如果没有出现就为-1
String substring(int index);从指定位置截取剩下的字符串
String substring(int index,int end);从index开始到end结束截取字符串，包含index不包含end
String toUpperCase();转大写
String toLowerCase();转大写
String trim()去除首尾的空格
boolean endsWith(String str);是否以str结尾
boolean startsWith(String str);是否以str开头
boolean equals(String str);字符串的值是否相等
String replace(String oldStr,String newStr);将旧字符串替换成新字符串
String[] split(String str);将字符串以str的形式切割成数组
    
public static void main(String[] args) {
    //注意事项：String的方法都需要返回值接受
    
    
    String str = "abc123";
    System.out.println(str.length());//返回字符串的长度6
    char a = str.charAt(1);
    System.out.println(a);//b
    System.out.println(str.indexOf("aaa"));//-1
    System.out.println(str.indexOf("123"));//3
    System.out.println(str.indexOf("12"));//3
    System.out.println(str.indexOf("c"));//2
    System.out.println("~~~~~~~~~~~~~~~~~~~~");
    System.out.println(str.substring(2));//c123    包括2 包括制定的位置
    System.out.println(str.substring(2,4));//c1    包括2,不包括4  技巧：凡是JAVA或JS 都有一句：左包含，右不包含
    System.out.println(str.toLowerCase());//abc123
    System.out.println(str.toUpperCase() );//ABC123
    String str = "  11  22  ";
    //注意事项：String的方法都需要返回值接受
    str.trim();
    System.out.println(str);//这里依然是原有的str 并没有去除空格
    
    String str = "www.4399.com";
    System.out.println( str.startsWith("www."));//T
    System.out.println( str.endsWith(".com")   ||  str.endsWith(".cn")    );//T
    
    System.out.println(str.replace("w","你"));
    //replcae既可以实现替换 也可以实现删除
    System.out.println(str.replace("9",""));
    
    String str = "1-2-3-4-5-6-7-8";
    String[] split = str.split("-");
    for(int i = 0 ;i<split.length;i++) {
        System.out.println(split[i]);
    }
    
}

五.题目1
public static void main(String[] args) {
分别打印该字符串中，数字，小写字母，大写字母和符号的个数
    String str = "22aaaAAAA```~~";
    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;
    
    for(int i = 0 ; i <str.length();i++) {
//            System.out.println(str.charAt(i));
        if( str.charAt(i) >='0'  &&  str.charAt(i)<='9'  ) {
            a++;
        }else if(str.charAt(i) >='a'  &&  str.charAt(i)<='z') {
            b++;
        }else if(str.charAt(i) >='A'  &&  str.charAt(i)<='Z') {
            c++;
        }else {
            d++;
        }
    }
    
    System.out.println(a);
    System.out.println(b);
    System.out.println(c);
    System.out.println(d);
    
    
}

六.题目2
声明一个方法，该方法可以传入一个字符串。判断该字符串是否符合格式，并提示错误信息。要求如下：
    1.长度是否在10-16位。
    2.是否以yyzy开头
    3.是否以2023结尾
    4.是否包含“china”字符串
    5.是否为复杂密码（大写字母，小写字母，数字，字符。包含三类或以上）
 
public static boolean  a1(String str) {
    if(!(str.length()>=10 && str.length()<=16)) {
        System.out.println("长度有误");
        return false;
    }
    
    if(! str.startsWith("yyzy")) {
        System.out.println("不是以yyzy开头");
        return false;
    }
    
    if(! str.endsWith("2023")) {
        System.out.println("不是以2023结尾");
        return false;
    }
    
    if(str.indexOf("china") == -1 ) {
        System.out.println("没有包含china");
        return false;
    }
    //分别表示是否含有相对于的密码
    boolean a1 = false;
    boolean a2 = false;
    boolean a3 = false;
    boolean a4 = false;
    int index = 0;
    
    for(int i = 0 ; i <str.length();i++) {
        if( str.charAt(i) >='0'  &&  str.charAt(i)<='9'  ) {
            a1 = true;
        }else if(str.charAt(i) >='a'  &&  str.charAt(i)<='z') {
            a2 = true;
        }else if(str.charAt(i) >='A'  &&  str.charAt(i)<='Z') {
            a3 = true;
        }else {
            a4 = true;
        }
    }
    
    if(a1) {
        index++;
    }
    if(a2) {
        index++;
    }
    if(a3) {
        index++;
    }
    if(a4) {
        index++;
    }
    //判断a1 a2 a3 a4 四个变量中 只要有3个或4个 true即可成功
    if(index<3) {
        System.out.println("密码不够复杂");
        return false;
    }
    
    System.out.println("密码格式正确");
    return true;
}

public static void main(String[] args) {
    String str = "yyzy1china--2023";
    boolean a1 = a1(str);
    System.out.println(a1);
}

七.StringBuffer
如果某个字符串需要经常被更改例如密码，那么推荐使用StringBuffer来声明。
语法如下：
StringBuffer str = new StringBuffer( String str );
备注：不能像String那样直接声明。
StringBuffer的特点：对字符串的增删改查都是在原有的基础上进行修改，
而非像String一样。

    StringBuffer str= new StringBuffer("aaa");
        StringBuffer常见的方法(和String的方法大同小异，列举出几个不同的)
        append(Object o);  往尾部添加任意类型的值。
        注意：这里不像String一样，一定需要返回值接受。
        insert(int I,Object o);在指定位置插入指定类型数据
    str.append("你好");
    str.append(true);
    str.append(123);
    System.out.println(str);
    str.insert(2, "bbb");
    System.out.println(str);
        
        
        String str = "1234";
        str.replace("1","aa");
    System.out.println(str);无法修改成功，因为上面没有加返回值    
}

八.测试String和StringBuffer的执行效率
通过for循环，在字符串尾部添加若干次字符串实现。

思路1：如何计算某一段代码的执行时间
解答:在代码的前后分别声明开始的时间和结束的时间
System.currentTimeMillis()返回值是一个long  表示 计时功能  表示当前的时间为系统时间 单位是毫秒    
        
    String str = "";
    //定义开始时间
    long l1 = System.currentTimeMillis();
    for(int i = 1 ; i<=10000;i++) {
        str = str + i;
    }
    //定义结束时间
    long l2 = System.currentTimeMillis();
    System.out.println(l2-l1);//150
    
    StringBuffer str =new StringBuffer("");
    
    //定义开始时间
    long l1 = System.currentTimeMillis();
    for(int i = 1 ; i<=10000;i++) {
        str.append(i);
    }
    //定义结束时间
    long l2 = System.currentTimeMillis();
    System.out.println(l2-l1);//150
    
    //结论：StringBuffer如果修改字符串 比String效率高的多。
    //衍生：Java的世界里面。一行代码的区别，带来的效率是上百倍甚至上千倍。
    //字符串的长度是有上限的  当你打印一个字符串出现空白的时候 就应该想到这个问题

九.Date
1.注意：Date 日期 和 Data 数据  
数据库：Database
            Java中针对时间日期类型提供了Date工具类。
            使用之前需要进行导包，和Scanner类非常类似: java.util.Date
            注意是util下的Date！
            
            导包：大部分的常用包都没有导入 ，原因：Java自带的一个包叫做 Java.lang.*包 该包下得类都是自动导入
            例如String  System
          
            需要的手动导入：Scanner
            
         常见的获取Date对象方式如下：
            Date d = new Date();//获取当前时间
            常见的过时方法：···
        

@SuppressWarnings("deprecation")
    public static void main(String[] args) {

        Date d = new Date();//下面的方法是过时的，但是这个对象不过时
        System.out.println(d);//发现：结果是对中国人不友好的
        //所以需要通过大量的过时方法来对中国人民友好
        //过时方法：仅仅是针对  大量的用户   翻译：如果你的项目很多很多人使用，就不推荐使用下面的方法
        //如果用户数量较少，可以使用，但是不推荐。
        int year = d.getYear();
        System.out.println(year+1900);
        int month = d.getMonth();
        System.out.println(month + 1);
        int date = d.getDate();
        System.out.println(date);
        int h = d.getHours();
        int m = d.getMinutes();
        int s = d.getSeconds();
        System.out.println(h+":" + m + ":" + s);
    }

2.SimpleDateFormat类
            由于Date对象的99%的方法都已经过时
            备注：Date d = new Date();还是没有过时，依然是获取当前时间的唯一方法。
            
            所以Java提供了SimpleDateFormat类，来替代Date的绝大部分方法，来对时间进行操作。
            Simple:简单的
            Date：日期
            Format：格式
            
            
            语法如下：
            SimpleDateFormat sdf = new SimpleDateFormat(“日期的具体格式”);
            日期具体格式如下：
            yyyy-MM-dd HH:mm:ss
            yyyy/MM/dd HH:mm:ss
            yyyy-MM-dd
            HH:mm:ss
            格式可以随便改，但是字母不能。yyyy表示年  MM表示月  dd日期   HH小时 mm分钟 ss秒
            
            注意：yyyy和MM 和dd和mm和ss  是固定的
            但是HH表示24小时制的时间
            hh表示12小时的时间
            
            其中字母定死了，符号可以根据场景改变。
            字母可以省略，例如只保留年月日或只保留时分秒。
      
        public static void main(String[] args) throws Exception {

       //如何获取当前时间
       //1.定义时间的格式
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
       //2.获取当前时间
       Date d = new Date();
      //3.格式化时间
       String str = sdf.format(d);
       System.out.println(str);
        
        //某些场景：可能需要过去或未来的时间 方法如下：
        String str = "2030/8/8   12:12:12";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        Date date = sdf.parse(str);
        System.out.println(date);

十.Math类
        Java提供了Math类来执行基本的数学运算。
        该类处于java.lang下，所以使用无需导包。
        该类下的所有方法都是静态方法，故无需new对象。
   
    public static void main(String[] args) {
        //floor 地板
        //ceil  天花板
        
//        doule Math.floor(double x);  向下取整，但是依然是double类型。
        System.out.println(Math.floor(1.1));//1.0
        System.out.println(Math.floor(1.0));//1.0
        
//        double Math.ceil(double x);向上取整，但是依然是double类型
        System.out.println(Math.ceil(1.1));//2.0
        System.out.println(Math.ceil(1.0));//1.0
        
//        long Math.round();四舍五入
        System.out.println(Math.round(1.1));//1
        System.out.println(Math.round(1.5));//2
        System.out.println(Math.round(1.9));//2
        
        //总结：四舍五入如果碰到± xxx.5 优先往大的数走
        System.out.println(Math.round(-1.1));//-1
        System.out.println(Math.round(-1.5));//-1
        System.out.println(Math.round(-1.9));//-2
        
//        double Math.random();取一个大于等于0但是小于1的小数  官方概念是这样，但是实际上可以不用考虑0
        System.out.println(Math.random());     
    }

    学会看API（教学文档，可以了解一些方法的组成以及如何使用）：语法如下：
    数据类型  方法名(参数列表);
    数据类型： 方法的返回值

十一.题目3
            利用生成10000次  1-10的随机数，分别统计次数
            然后打印在控制台上。

1.一般做法
public static void main(String[] args) {
//        Math.random()*10+1;//  [0,1)*10 = [1,11) --向下取整 [1, 10]
//        System.out.println( (int) Math.floor(  Math.random()*10+1));
        
        //分别统计1-10的次数
        int a = 0;
        int b = 0;
        int c = 0;
        int d = 0;
        int e = 0;
        int f = 0;
        int g = 0;
        int h = 0;
        int i1 = 0;
        int j = 0;
        for(int i = 1;i<=100000;i++) {
            int r = (int) Math.floor(  Math.random()*10+1);
            
            switch (r) {
            case 1:
                a++;
                break;
            case 2:
                b++;
                break;
            case 3:
                c++;
                break;
            case 4:
                d++;
                break;
            case 5:
                e++;
                break;
            case 6:
                f++;
                break;
            case 7:
                g++;
                break;
            case 8:
                h++;
                break;
            case 9:
                i1++;
                break;
            case 10:
                j++;
                break;
            }
        }
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(e);
        System.out.println(f);
        System.out.println(i1);
        System.out.println(g);
        System.out.println(h);
        System.out.println(j); 
    }

2.简化版
public static void main(String[] args) {
        int arr[] = new int[11];
        //arr[1] = 0;arr[2] = 0;arr[3] = 0;
        
        
        for(int i = 1;i<=100000;i++) {
            int r = (int) Math.floor(  Math.random()*10+1);
            arr[r] = arr[r] + 1;
        }
        for (int i = 1; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        
    }

十二.包装类
           包装类是专门针对于基本数据类型而言。
            由于基本数据类型没有方法或属性。
            为了更加方便对基本数据类型的值进行操作，Java提供了八大基本数据类型的包装类。
            
            boolean   byte
            char      short
            int       float
            double    long
            
            Boolean    Byte
            Character  Short
            Integer    Float
            Double     Long
        
        //包装类如何声明变量 和String一样
        Integer a = 123;//直接声明
        Integer b = new Integer(123);//通过构造方法声明
        
        //包装类的用途：
        //1.作为实体类属性的数据类型，替换基本数据类型。
        //以前的写法 见下方的Student类
        Student s = new Student(123, "张三", 18,18);
        Student s1 = new Student();
        System.out.println(s);
        System.out.println(s1);
        
        //缺点：基本数据类型的默认值为0   而引用数据类型的默认值为null
        
        //2.将字符串转为对应的基本数据类型
        String str = "123445";
        int i = Integer.parseInt(str);
        System.out.println(i);    
        double d = Double.parseDouble(str);
    }
}

class Student {
    private int id;
    private String name;
    private int age;
    private Integer age123;
    public Student(int id, String name, int age,Integer age123) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    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 "Student [id=" + id + ", name=" + name + ", age=" + age + ", age123=" + age123 + "]";
    }

十三.包装类的补充
仅做了解为了面试 实际开发用不到

    public static void main(String[] args) {
        //自动装箱值得是：将基本数据类型 变成  包装类
//        int a = 11;
//        Integer b = a;//此过程就是自动装箱
//        
//        //自动拆箱值得是：将包装类转成基本数据类型
//        Integer c = 1;
//        int d = c.intValue();
//        
        
        //常见面试题：
        
//        String str1 = "你好";
//        String str2 = "你好";
//        String str3 =  new String("你好");
//        System.out.println(str1==str2);//true
//        System.out.println(str1==str3);//f
//        
//        System.out.println(str1.equals(str2));//t
//        System.out.println(str1.equals(str3));//t
//        
//        System.out.println(str2==str3);//f
//        System.out.println(str2.equals(str3));//t
        
        //Integer和String的类似度高达99%
//        Integer str1 = 1;
//        Integer str2 = 1;
//        Integer str3 = new Integer(1);
//        System.out.println(str1==str2);//true
//        System.out.println(str1==str3);//f
//        
//        System.out.println(str1.equals(str2));//t
//        System.out.println(str1.equals(str3));//t
//        
//        System.out.println(str2==str3);//f
//        System.out.println(str2.equals(str3));//t
        
        Integer str1 = 1111;
        Integer str2 = 1111;
        Integer str3 = new Integer(1111);
        System.out.println(str1==str2);//false
        System.out.println(str1==str3);//f
        
        System.out.println(str1.equals(str2));//t
        System.out.println(str1.equals(str3));//t
        
        System.out.println(str2==str3);//f
        System.out.println(str2.equals(str3));//t
        
        
        //Integer直接声明变量和String非常类似 ，都有一个类似缓存池的存在
        //String直接声明：先去缓存池找是否存在，如果不存在就new一个，如果存在就直接引用
        //Integer直接声明：现在-128~127的缓存池找是否存在，如果不存在就new一个，如果存在就直接引用
        
    }