Object类，String类，Scanner类

1.Object类
1.“==”与“equals”的区别
运算符在比较基本数据类型时候，就是比较的值是否相同
在比较引用数据类型的时候，比较的是地址值是否相同
equals运算符只能比较引用数据类型，且默认情况下也是比较的地址是否相同
如果比较两个引用的里面的基本数据类型，则需要重写equals方法

public class Test {
    public static void main(String[] args) {
        Studen lisi = new Studen(20, "lisi");
        Studen lisi2=new Studen(20,"lisi");
        Studen zhaoliu = new Studen(30, "zhaoliu");
        System.out.println(lisi.equals(zhaoliu));
        System.out.println(lisi.equals(lisi2));

重写equals方法

public class Studen {
    private int age;

    public int getAge() {
        return age;
    }

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

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

    public String getName() {
        return name;
    }

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

    private String name;
    @Override
    public  boolean equals(Object obj){
        if (this==obj){
            return true;
        }
        if (!(obj instanceof Studen)){
            return  false;
        }
        Studen s2=(Studen) obj;
        return age==s2.age&&name.equals(s2.name);

    }
}

public class Test {
    public static void main(String[] args) {
//        API:应用程序接口
        Object o = new Object();//该包下的类不需要导包
//        Object类中常用的方法
        System.out.println(o);//在打印一个东西时,其实是默认调用了ToString方法,即 o.ToString
        System.out.println(o.toString());//返回类型是String类型,字符串类型
//        获取该对象的哈希码值
        int code =o.hashCode();
        System.out.println(code);//根据o的地址值返回一个哈希码值,不同对象的哈希码值也是不一样的
//        Java万物皆对象的思想
        Class cl=o.getClass();
    }
}
//toString方法重写经常用于构造方法是有参的,输出对象引用的时候,只要改写了toString,就可以直接输出有参构造方法的值了
//"=="运算符用于比较两个地址值是否相同
//equals 方法在父类Object类中也是比较两个地址值是否相同,但是通过改写eauals和HashCode方法,可以比较两个的字面值是否相同了

2.Scanner类

import java.util.Scanner;

public class ScannerUntils {
    private ScannerUntils() {
    }
    public static int use(Scanner sc){
        while (true){
            sc=new Scanner(System.in);
            boolean b=sc.hasNextInt();//为什么这里只判断一次，而不是跟nextInt()一样没循环一次都让重新输入一个
//            hasNextInt（）有点像缓存的机制，当调用它的时候，它的空间会存入一个值，再次调用不会覆盖或者增加，而是保持原来的值。。
            if (b){
     int num=sc.nextInt();
//                System.out.println(num);
                return  num;
//                break;
            }else {
                System.out.println("输的不对重新输");
            }
        }

    }
}

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        常用基本类型字符串录入方法
        int a=scanner.nextInt();
        double b=scanner.nextDouble();
        float c=scanner.nextFloat();//等等，根据自己情况来用，好多了就在这不一一打了
        boolean d=scanner.nextBoolean();//这个只能输入true或者false
//        String类型字符串录入方法
        String e=scanner.nextLine();//这是第一种方式，这种方式会录入回车键，推荐经常使用，如果又碰到小尴尬的情况的话（比如敲完
        //回车键然后被录入了，实际上不想录那个回车键，那样的话就在重新new一个Scanner对象就可以了 ）
        String f=scanner.next();//这是第二种方式，这种方式不会录入回车键，但是如果你打印了一些字之后要空几格，或者有换行的，
//        他就只会录入你的有换行或者空格之前的内容，后面就不录了。


    }
}

public class Test1 {
    public static void main(String[] args) {
//        如果用户录入的类型不是我们想要的类型，按照之前写的就会报错，导致程序的兼容性比较差，所以要提高兼容性,就用下面的方法
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数");
        boolean b = scanner.hasNextInt();//判断对象输入的是不是整数类型，进行预判
        if(b){
            int num =scanner.nextInt();
            System.out.println(num);
        }else
        {
            System.out.println("输入的不是整数,请重新输入");
        }
        while (true){
            System.out.println("请再输入一个数");
            int a=scanner.nextInt();
            if (a==20){
                System.out.println("输入对了");
                break;
            }else
            {
                System.out.println("重新输");

            }
        }
        }
//        System.out.println("dasddads");
    }

用完Scanner功能后，记得调用close方法释放资源

ublic class Test2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数");
        System.out.println(ScannerUntils.use(scanner));
        scanner.close();
//Scanner功能用完之后，可以用close方法关闭Scanner功能，释放资源（后面IO流常用）
    }
}

3.String 类
String类介绍

ublic class Test {
    public static void main(String[] args) {

    }
        String s = new String("dsadadsa");//这个是有参的String类，里面可以写字符串，常用
    String b=new String();//这个是无参的 String构造方法，里面是空串，这个不咋常用

    }
//字符串是多个字符组成的序列
//字符串可以看作是字符数组
//字符串的每个字符，从左往右都可以看成是有索引的，从0开始
//==========================
//1.String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
//2.字符串是常量；它们的值在创建之后不能更改。
//如果输出的是地址值，那么这个类就没有重写toString方法
//如果输出的不是地址值，那么这个类就是重写了toString方法
//""只有两个引号，这个叫空串，打印出来什么都没有

public class Test2 {
    public static void main(String[] args) {

     byte [] aa=new byte[]{};
     byte[] aaa=new  byte[4];
     int[] [] b=new int[6][3];
     int [][] c=new int[][]{{},{},{},{}};
     int [] []m={{},{},{}};
//     定义字节数组
     byte[] a={97,97,98,99,98,99,100};//这样输的话，它会自动那这个对应ASK码表去，将其数字对应转换成字符串（记住就行）
//        将字节数组转换成字符串（记住，他的功能就是转换出来）
//String(byte[] bytes)
//通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。通俗点就是把形参的字节数组转换成字符串
        String cc=new String(a);
        System.out.println(cc);
        System.out.println("============");
//        把字节数组的一部分转换成字符串，第二个参数表示从第几个元素开始，第三个参数表示把从第几个元素开始的长度为几的元素都转成
//        字符串
        String s = new String(a, 0, 3);//将a数组从第0个字节开始（包括第0个），将三个元素转成字符串
        System.out.println(s);//只显示转换字符串的部分，别的不显示


    }
}

public class Test3 {
    public static void main(String[] args) {
//        把字符数组转成字符串
        char[] a={'a','b','c','d','的','都'};
//        可以通过构造方法将字符数组转换成字符串
//        String(char[] value)
//        分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
        String s = new String(a);
        System.out.println(s);//这是将全部的字符数组转换成字符串
        s=new String(a,2,2);//这是将字符数组的部分字符转换成字符串，从字符数组的第2个元素开始（包括第2个），将
//        后面2个元素转换为字符串
        System.out.println(s);
    }
}

public class Test4 {
    public static void main(String[] args) {
        String s = new String("fsdfsdfsdfdsfdsfdsfsd");
//        获取字符串的长度
        int length=s.length();
        System.out.println(length);
//        Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
//        什么意思？就是说每个字符串不需要new，直接写出来就是一个对象，例如：
        int length1 = "sadasdasdasdas".length();//直接写出来就是一个对象，当然对象类型都为String类型
//        最常用的写法都是：
       String a= "dadadsadds";//不用new，直接就是对象
        int length2 = a.length();
        System.out.println(length2);
    }
}

public class Test5 {
    public static void main(String[] args) {
//        字符串是常量；它们的值在创建之后不能更改。
//        在JDK1.8之后，堆内存中有个字符串常量池
//        字符串是常量；它们的值在创建之后不能更改，指的的是，字符串的值不能被改变，你改变的无非是这个指向，指向是可以被改变的
//        就像new对象一样，s=new b(); 后s还可以=new c();指向是可以便得
//        每个字符串都是一个对象，是对象就会有地址，每写出一个字符串常量来，这个地址都会放到堆内存得常量池中
//        注意一下:两个字符串之间用"+"相连接得时候,直接合并成一个完整得字符串,并且给个地址当道字符串常量池中
    }
}

public class Test6 {
    public static void main(String[] args) {
//        以下这两种情况是由区别得
        String s1="hello";//这句话创建了一个对象
        String hello1 = new String("hello");//这句话创建了两个对象 在4-26内存图中有
//        对第二种情况,第一个,hello这个字符串直接构建了一个对象,有了一个地址x1,然后,new 对象这句话又构建了一个对象
//        它里面存着刚才得字符串地址x1,然后new对象这个地址为x2,给了引用变量hello1
       String s2="helloJAVA";
        String s3 = new String("helloJAVA");
        System.out.println(s2==s3);
        System.out.println(s2.equals(s3));//String类重写了equals方法,直接比较其字面值是否相等,不论你什么形式,它值比较字面值
//        所以是true
        boolean j="abc".equals("abC");
        System.out.println(j);//equals区分大小写
        boolean h="abc".equalsIgnoreCase("ABC");//这个方法不区分大小写(忽略大小写)
        System.out.println(h);
    }
}
//String 类重写了toString方法,输出的不在是该引用的地址值,而是打印字符串的字面内容
//String 类重写了equals方法，不在比较两个字符串的地址值是否相同，而是比较两个字符串字面上的内容是否相等，区分大小写

String功能介绍

//String类的判断功能
public class Test {
    public static void main(String[] args) {
//        String方法：
//        这个方法用于判断两字符串字面值是否相等（忽略大小写）
      boolean a="ABC".equalsIgnoreCase("abc");
        System.out.println(a);
//        String方法：
//        判断字符串是否为空串
        boolean b="ddasd".isEmpty();
        System.out.println(b);
//        判断字符串是否以某个字符串开头
        boolean h = "王语嫣".startsWith("王");
        boolean h1 = "王语嫣".startsWith("王语");//看的是这个字符串的第一个字
        System.out.println(h);
//判断某个字符串是不是以某个字符串结尾,注意，无论开头还是结尾，这个字符串除了空串之外不能是单独的一个字
        boolean h2 = "段誉".endsWith("誉");
        boolean h4 = "欲语泪先流".endsWith("泪先流");//看的是这个字符串的最后一个字
        System.out.println(h4);
//        判断一个字符串是否包含一个字串：
        boolean h3 = "我想带你去浪漫土耳其".contains("土耳其");
        System.out.println(h3);
    }
}

package String类常用功能;
//String的获取功能
public class Test1 {
    public static void main(String[] args) {
//        根据索引获取单个字符:
char h="1234我爱你".charAt(2);//单个字符用char类型,charAt()中填的是字符串的索引值或者叫下标值
        System.out.println(h);
        String m="sdasdadadds";
        char h1=m.charAt(m.length()-1);//获取最后一个
//        查找该字符或者该字符串第一次出现的索引
        String k="我爱你我爱你我爱你";
//        indexof从头开始找，并且从左往右
        int index=k.indexOf("爱");//里面可以放单个字符，也可以放一段字符串，也是从这一小段的字符串的第一个字找
        System.out.println(index);
//        从指定索引往后查找
        int index1=k.indexOf("爱",2);//从索引值为2的地方开始找，后面所出现的'爱'这个字符
        System.out.println(index1);
        int index2=m.indexOf("da",m.indexOf("da")+1);//可以写一个字符，也可以写一个字符串，这个听常用的，字符串的
//        的话也是找字符串的第一个字符
        System.out.println(index2);
//        如果没有找到，就会返回-1，-1经常是表示找不到。
//        =======================================================
//        从后往前找第一次出现的字符或字符串的索引
        String f="fasdfasffbgsdgbsgadgadgadgdagdagda";
        int index6=f.lastIndexOf("g");
        System.out.println(index6);
        int index4=f.lastIndexOf("d",10);//表示从索引值为10 的地方从后往前找，找"d"这个字符首次出现的位置
        System.out.println(index4);




//        截取字符串
        String l="我在人民广场吃着炸鸡，而此时此刻你在哪里";
        String k1=l.substring(2);//从指定索引处开始截取，截取到末尾返回，会把索引值截取进去
        System.out.println(k1);
//        如果想截取一段，可以定义两个索引
        String substring = l.substring(0, 5);//含头不含尾，包含头部索引的字符，但是不包含尾部包含的字符

    }
}

package String类常用功能;
//遍历字符串
public class Test2 {
    public static void main(String[] args) {
    String a="我在任命广场吃着炸鸡大书法家反馈发放了咖啡尼可拉省的方式的";
//    char h;

        for (int i = 0; i < a.length(); i++) {
          char  h=a.charAt(i); //为啥这里可以直接写 char h,因为个循环每赋值一次就把h丢掉了，再进来是对h进行重新的定义与赋值
//            上述是自己总结的
            System.out.println(h);
        }
        for (int i = a.length()-1; i >= 0; i--) {
            char h=a.charAt(i);
            System.out.println(h);
        }
    }
}

//如果要求统计问题的时候，一定要写上统计变量
public class Test4 {
    public static void main(String[] args) {
//        统计下列字符串中，小写字符，大写字符以及数字字符的个数：
        //如果要求统计问题的时候，一定要写上统计变量
        int da=0;
        int xiao=0;
        int shu=0;
        String a="fdffdfaffhfkgljdlfgj4579023fh32FASFSAF43hfSDFHJKKDSHFSDJV983g30jfk29FASFSA4f3209fh230";
        for (int i = 0; i < a.length(); i++) {
            char h=a.charAt(i);
            if(h>='a'&&h<='z'){

           xiao++; }else if (h>='A'&&h<='Z'){
                da++;
            }else if (h>='1'&&h<='9'){
                shu++;
            }

        }
        System.out.println("大写字母为"+da+"个");
        System.out.println("小写字母为"+xiao+"个");
        System.out.println("数字为"+shu+"个");
    }
}

package String类常用功能;
//String类中与转换功能有关的方法
public class Test5 {
    public static void main(String[] args) {
//把一个字符串，转换为字节数组
        String h="ddadasdd";
        byte[] bytes=h.getBytes();//这个方法，将字符串转换为字节数组
        for (int i = 0; i < bytes.length; i++) {
            int a=bytes[i];
            System.out.println(a);
        }
        System.out.println(bytes.length);
//        把字节数组转换成字符串
        String m=new String(bytes);
        System.out.println(m);
        String s="我爱你";//对于UTF-8编码制度：一个汉字对应三个字节，一个字节存一个数字，所以一个汉字对应着三个数字
        byte[] kk=s.getBytes();
        for (int i = 0; i < kk.length; i++) {
            int a=kk[i];
            System.out.println(a);
        }
        System.out.println(kk.length);
        String s1 = new String(kk, 0, 6);//一个汉字对应三个字节，也就是在byte数组里对应着三个汉字，所以需要6个长度的数组
        System.out.println(s1);
    }
}

package String类常用功能;
//将字符串转换为字符数组
public class Test6 {
    public static void main(String[] args) {
        String l="草泥马深度负反馈拉法兰发了疯";
        char[] chars=l.toCharArray();//将字符串转换为字节数组
//        System.out.println(chars.length);
        for (int i = 0; i < chars.length; i++) {
            char k=chars[i];
            System.out.println(k);
        }
//        把一个字符数组转换成字符串
        String m=new String(chars);
        System.out.println(m);
    }
}

package String类常用功能;
//value of方法，这是静态方法
public class Test7 {
    public static void main(String[] args) {
//        valueOf()静态方法，可以把很多类型转换成字符串
//        把一个整数转换成字符串
        int num =100;
        System.out.println(num+"");//这样就把100变成了字符串类行

        String a=String.valueOf(100);//这样直接一键将整数型100转成了字符串型
        String b=String.valueOf('d');//这样直接一键将zifu型d转成了字符串型
        String c=String.valueOf(1010L);//……
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        String d=String.valueOf(new char[]{'a','b','c','d'});//valueof方法这是
        String e=new String(new char[]{'a','b','c','d'});//用构造方法转
        String s1="dasdasFFSSd".toUpperCase();//将小写字母转为大写字母
        System.out.println(s1);
        String s2="FSDFFFASFSfasf".toLowerCase();//将da写字母转为xiao写字母
        System.out.println(s2);
//        拼接字符串 除了加号拼的另一种方法
        String s3="dass".concat("dsada").concat("dasdasda").concat("dasdsa");//链式变成
        System.out.println(s3);

    }
}

package String类常用功能;
//替换功能

public class test8 {
    public static void main(String[] args) {
        String str="奥巴马和特朗普";
        String  str1=str.replace('奥','*');//将奥字替换为*
        System.out.println(str1);
        String s = str.replace("奥巴马", "***");//可直接替换字符，也可以替换字符串
        System.out.println(s);
//        链式编程:
        String s1 = str.replace("奥巴马", "**").replace("特朗普", "****");
        System.out.println(s1);
    }
}

package String类常用功能;
//trim功能:去除字符串两端空格
public class Test9 {
    public static void main(String[] args) {
        String a= "       1234      ";
        String trim = a.trim();
        System.out.println("======"+trim+"======");
    }
}

package String类常用功能;
//字符串的比较（除equals的另一种方法）
//现在的编码格式是默认的UTF-8，英文与ASKII表是一致对应的，中文的暂时不清楚
public class Test10 {
    public static void main(String[] args) {
        boolean a="abc".equals("ddd");//这是布尔类型的比较
//        比较字符串，返回值是int类型
//        两字符串长度相同时
   int i="abc".compareTo("bBC");//其原理是直接用其对应的ASKII码表的值相减，相同时就返回0,先从第一个值开始相减，如果第一个为0
//        那么就开始减第二个值,以此类推,一直到不相同的那个数或者都减完都是0位置,只要有一个不为0的值得时候,返回这个值,结束.
        System.out.println(i);
        int ii ="abcd".compareTo("SB");//如果长度不一样是时，就直接按长度去减了
        System.out.println(ii);
//        这个比较方法有时是必须需要返回类型是整数型时用到的
    }
}