标签：Java String int System 初学 day10 println public out

Java 10

常用类

1、API概述

API (Application Programming Interface)

应用程序编程接口
编写应该机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为Xxx Robot API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类。

2、Object类

java中所有的类默认都有一个共同的父类：Object

1、概述

类层次结构的根类
所有类都直接或间接的继承自该类

2、构造方法

public Object()
子类的构造方法默认访问的是父类的无参构造方法

3、Object类的成员方法

public int hashCode()//返回对象的哈希码值。 可以看作地址值的另外一种表现形式
    
public final Class getClass()//返回此 Object的运行时类。 获取当前类的class文件对象, 一个类全局只有一个在方法区中
    
public String toString()/*
打印一个引用数据类型的对象名，默认调用的是类中的toString()方法
若我们自己没有编写该方法，默认使用父类Object类的toString()方法
而父类中默认的toString()打印的是一个地址值
我们今后打印一个对象名的时候，输出是地址值意义不大，我们今后更多的是想看一个对象中成员变量值的情况
要想实现上面的输出成员变量值的话，重写toString()方法，这样调用的就是自己重写后的toString()
自动生成即可
*/  	
    
public boolean equals(Object obj)
/*
默认情况下，若对象类中没有自己编写equals方法，默认使用的是父类中Object类中的equals方法
而父类中Object类中的equals方法底层调用的是==比较，若比较的是引用数据类型，比较的是地址值
*/
    
protected void finalize()//垃圾回收

protected Object clone()
/*
java中并不是所有的类都可以被克隆，只有授权的类的对象才可以使用克隆方法
    我们通过阅读帮助文档后发现，若一个对象的类没有实现Cloneable接口的话，是不可以调用clone方法的
    然后，我们再去看Cloneable接口的时候，发现该接口中没有任何抽象方法，今后像这样的接口称之为标记接口

    克隆在IT行业中，称之为拷贝。
    拷贝分为两种：
        1、浅拷贝
        2、深拷贝

    面试题：Object类中的clone是浅拷贝还是深拷贝。答：是浅拷贝
*/

public int hashCode()

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

public class ObjectDemo1 {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
        System.out.println(student.hashCode());
        System.out.println(student1==student2);
    }
}

/*
输出：1163157884
	 false
*/

tip:
比较：
1、比较的是两个基本数据类型的话，比较两个数值是否相等
2、比较的是两个引用数据类型的话，比较的是两个对象的地址值是否相等

public final Class getClass()

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

public class ObjectDemo1 {
    public static void main(String[] args) {
    	Class c1 = student.getClass();
        System.out.println(c1);
    }
}

/*
输出：class day10.object.Student
*/

public String toString()

class Student{
    String name;
    int age;

    public Student() {
    }

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


public class ObjectDemo1 {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student);
        System.out.println(student.toString());
        //getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
}
/*
输出：Student{name='null', age=0}
 	 Student{name='null', age=0}
*/

=========================================================================================

//重写toString()方法
class Student{
    String name;
    int age;

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ObjectDemo1 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 18);
        System.out.println(s1);
        System.out.println(s1.toString());

    }
}
/*
输出：Student{name='张三', age=18}
	 Student{name='张三', age=18}
*/

一个标准类的4.0写法

成员变量: 私有化
构造方法: 有参，无参
成员方法: getXxx()和setXxx()
toString(): 重写父类中的toString()

public boolean equals(Object obj)

package day10.object;

import java.util.Objects;

class Student1{
    String name;
    int age;

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

    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
    
}

public class ObjectDemo2 {
    public static void main(String[] args) {
        Student1 s1 = new Student1("张三",21);
        Student1 s2 = new Student1("李四", 22);
        System.out.println(s2.equals(s1));
        s2.name="张三";
        System.out.println(s2.equals(s1));
    }
}
/*
输出：false
	 false
*/
=========================================================================================
//重写equals()方法

import java.util.Objects;

class Student1{
    String name;
    int age;

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

    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student1 student1 = (Student1) o;
        return age == student1.age && Objects.equals(name, student1.name);
    }
    
}

public class ObjectDemo2 {
    public static void main(String[] args) {
        Student1 s1 = new Student1("张三",21);
        Student1 s2 = new Student1("李四", 22);
        System.out.println(s2.equals(s1));
        s2.name="张三";
        s2.age = 21;
        System.out.println(s2.equals(s1));
    }
}
/*
输出：true
	 true
*/

protected Object clone()

class Demo1{
    int a =10;
}


class Student2 implements Cloneable {
    String name;
    int age;
    Demo1 demo1;

    public Student2(String name, int age,Demo1 demo1) {
        this.name = name;
        this.age = age;
        this.demo1=demo1;
    }

    @Override
    public String toString() {
        return "Student2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", demo1=" + demo1 +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class ObjectDemo3 {
    public static void main(String[] args)throws Exception {
        Demo1 d1 = new Demo1();
        Student2 s1 = new Student2("张三", 22,d1);
        Student2 s2 = new Student2("李四", 24,d1);
        System.out.println("s1:"+s1);
        System.out.println(s1.hashCode());
        System.out.println("=========================================");
        //首先，如果此对象的类不实现接口Cloneable ，则抛出CloneNotSupportedException 。
        Object o1 = s1.clone();
        System.out.println("o1:"+o1);
        System.out.println(o1.hashCode());
    }
}

tip:

拷贝又分为浅拷贝和深拷贝

浅拷贝 (Shallow Copy)

只复制对象的引用，内存地址指向同一块区域。
如果原对象包含引用类型的属性，浅拷贝后的对象和原对象共享这些属性的引用。
修改共享的引用属性会影响到原对象和拷贝对象。

深拷贝 (Deep Copy)

复制对象及其所有引用类型属性的副本。
深拷贝后的对象与原对象完全独立，修改一个对象不会影响另一个对象。
实现深拷贝通常需要递归复制所有引用的对象。

3、scanner类

概述

Scanner: 一个简单的文本扫描器，可以使用正则表达式解析原始类型和字符串。

构造方法

Scanner(InputStream source) //构造一个新的 Scanner ，产生从指定输入流扫描的值

Scanner sc = new Scanner(System.in);
//获取一个数字：
int i = sc.nextInt();
System.out.println(i);
//获取一个字符串
String s1 = sc.next();
System.out.println(s1);

//获取数字的时候，我们是不是只能够输入数字呢？    是的
System.out.println("请输入一个数字：");
//hasNextXxx()判断下一个输入的内容是否是指定类型
if(sc.hasNextInt()){
	int i = sc.nextInt();
	System.out.println(i);
}else {
	System.out.println("您输入的内容不是一个int类型的值！");
}

//        int i = sc.nextInt();
//        System.out.println(i);
//        String s1 = sc.next(); //无法接收换行等空白特殊字符
//        System.out.println(s1);
        //输入字符串的另外一种方法
//        String s1 = sc.nextLine(); //可以接收换行等空白特殊字符
//        System.out.println(s1);

4、String类

1、概述

由若干个字符构成的字符序列叫做字符串

Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
字符串不变; 它们的值在创建后不能被更改指的是字符串本身不能改，修改的是地址值
因为String对象是不可变的，它们可以被共享。（在常量池中被共享）
字符串可以被看作成一个字符数组

2、String类常用的构造方法

public String()
public String(byte[] bytes)
public String(byte[] bytes,int offset,int length)
public String(char[] value)
public String(char[] value,int offset,int count)
public String(String original)

public String()

//创建一个空字符串

public class StringDemo {
    public static void main(String[] args) {
        //public String() 创建一个空字符串
        String s1 = new String(); // 堆内存
        System.out.println("s1: " + s1);
        
        String s2 = "";// 常量池
        System.out.println(s1=s2);//false
        
    }
}

public String(byte[] bytes)

//将一个字节数组转成字符串

public class StringDemo {
    public static void main(String[] args) {
    	byte[] bytes = {97,98,99,100,101,102};
        	String s2 = new String(bytes);
        	System.out.println("s2: "+s2);    
    }
}


/*
输出：
s2: abcdef
*/

public String(byte[] bytes,int index,int length)

//从字节数组的某个位置开始，向后截取变成字符串

public class StringDemo {
    public static void main(String[] args) {
        byte[] bytes = {97,98,99,100,101,102};
        String s3 = new String(bytes, 2, 3);
        System.out.println("s3: "+s3);
    }
}


/*
输出：
s3: cde
*/

public String(char[] value)

//将一个字符数组转成一个字符串

public class StringDemo {
    public static void main(String[] args) {
       	char[] chars = {'我','爱','中','华'};
        String s4 = new String(chars);
        System.out.println("s4: "+s4);
    }
}

/*
输出：
s4: 我爱中华
*/

public String(char[] value,int index,int length)

//将字符数组一部分转成字符串

public class StringDemo {
    public static void main(String[] args) {
        char[] chars = {'我','爱','中','华'};
       	String s5 = new String(chars,1, 2);
        System.out.println("s5: "+s5);
    }
}

/*
输出：
s5: 爱中
*/

public String(String original)

//将字符串封装成一个String对象在堆内存中

public class StringDemo {
    public static void main(String[] args) {
      	String s6 = new String("你好");
        System.out.println("s6: "+s6); 
    }
}

/*
输出：
s6: 你好
*/

3、String类常用的判断功能

boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean startsWith(String str)
boolean endsWith(String str)
boolean isEmpty()
    
public class StringDemo3 {
	public static void main(String[] args) {
        
    }
}

boolean equals(Object obj)

//比较两个字符串的内容值

public class StringDemo3 {
    public static void main(String[] args) {
		String s1 = "hello";
        String s2 = "HellO";
        System.out.println(s1.equals(s2));
    }
}

/*
输出：
false
*/

boolean equalsIgnoreCase(String str)

//忽略大小写比较字符串内容值

public class StringDemo3 {
    public static void main(String[] args) {
		String s1 = "hello";
        String s2 = "HellO";
        System.out.println(s1.equalsIgnoreCase(s2));
    }
}

/*
输出：
true
*/

boolean contains(String str)

//判断大字符串中是否包含某一个小字符串

public class StringDemo3 {
	public static void main(String[] args) {
        String s3 = "今天的天气还可以李刚决定去洗个脚";
        System.out.println(s3.contains("李刚"));
    }
}

/*
输出：
true
*/

boolean startsWith(String str)

//判断字符串是否以某个字符串开头

public class StringDemo3 {
	public static void main(String[] args) {
        String s3 = "今天的天气还可以李刚决定去洗个脚";
        System.out.println(s3.startsWith("今天的天气数可以"));
    }
}

/*
输出：
false
*/

boolean endsWith(String str)

//判断字符串是否以某个字符串结尾

public class StringDemo3 {
    public static void main(String[] args) {
        String s3 = "今天的天气还可以李刚决定去洗个脚";
        System.out.println(s3.endsWith("洗个脚"));
    }
}

/*
输出：
true
*/

boolean isEmpty()

//判断字符串是否为空字符串，指的是内容是否为空

public class StringDemo3 {
    public static void main(String[] args) {
        String s4 = "";
        System.out.println(s4.isEmpty());
        String s5 = null;
        System.out.println(s5.isEmpty());
    }
}

/*
输出：
true
Exception in thread "main" java.lang.NullPointerException
	at Tool.StringDemo3.main(StringDemo3.java:8)       (编译错误)
*/

4、String类中的获取功能

int length()
char charAt(int index)
int indexOf(int ch)
int indexOf(String str)
int indexOf(int ch,int fromIndex)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)

int length()

//获取字符串中的字符个数，字符串长度

public class StringDemo4 {
    public static void main(String[] args) {
        String s = "李刚在数加学院中学习非常快乐！";
        System.out.println(s.length());
    }
}

/*
输出：
15
*/

char charAt(int index)

//根据索引获取字符串中某一个字符

//字符串可以被看作成一个字符数组
public class StringDemo4 {
    public static void main(String[] args) {
        String s = "李刚在数加学院中学习非常快乐！";
        System.out.println(s.charAt(10));
    }
}

/*
输出：
非
*/

int indexOf(int ch)

//根据ascii码值获取对应字符所在的索引位置,左边起第一个

//找到输出索引值，找不到输出-1
public class StringDemo4 {
    public static void main(String[] args) {
        String s2 = "qweasdsafhqe";
        System.out.println(s2.indexOf(87));
        System.out.println(s2.indexOf(104));
    }
}

/*
输出：
-1
9
*/

int indexOf(int ch,int fromIndex)

//从某个索引开始向后寻找某个字符，返回找到字符在整个大字符串中的索引位置

public class StringDemo4 {
    public static void main(String[] args) {
        String s2 = "qweasdsafhqe";
        System.out.println(s2.indexOf(97,5));
    }
}

/*
输出：
7
*/

int indexOf(String str)

//获取大字符串中小字符串的位置，返回小字符串第一个字符的索引

public class StringDemo4 {
    public static void main(String[] args) {
        String s2 = "qweasdsafhqe";
        System.out.println(s2.indexOf("sdsa"));
    }
}

/*
输出：
4
*/

int indexOf(String str,int fromIndex)

//从某个索引开始向后寻找某个字符，返回找到字符串第一个字符在整个大字符串中的索引位置

//找到输出索引值，找不到输出-1
public class StringDemo4 {
    public static void main(String[] args) {
        String s2 = "qweasdsafhqe";
        System.out.println(s2.indexOf("saf",3));
        System.out.println(s2.indexOf("sah",3));
    }
}

/*
输出：
4
-1
*/

String substring(int start)

// 从指定位置向后截取，返回新的字符串

public class StringDemo4 {
    public static void main(String[] args) {
        String s3 = "李刚是真的帅！江川很不服，钱志强觉得自己是最帅的！";
        String res1 = s3.substring(3);
        System.out.println(res1);
    }
}

/*
输出：
真的帅！江川很不服，钱志强觉得自己是最帅的！
*/

String substring(int start,int end)

//截取字符串中的一部分 [start, end)

public class StringDemo4 {
    public static void main(String[] args) {
        String s3 = "李刚是真的帅！江川很不服，钱志强觉得自己是最帅的！";
        String res2 = s3.substring(7, 12);
        System.out.println(res2);
    }
}

/*
输出：
江川很不服
*/

5、String转换功能

byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
static String valueOf(int i)
String toLowerCase()
String toUpperCase()
String concat(String str)

byte[] getBytes()

//byte[] getBytes() 将字符串转字节数组

public class StringDemo5 {
    public static void main(String[] args) {
        String s1 = "abcdefg";

        byte[] bytes = s1.getBytes();
        for(int i=0;i<bytes.length;i++){
            System.out.println(bytes[i]);
        }
    }
}

/*
输出：
97
98
99
100
101
102
103
*/

char[] toCharArray()

//将字符串转字符数组

public class StringDemo5 {
    public static void main(String[] args) {
        String s1 = "abcdefg";
        char[] chars = s1.toCharArray();
        for(int i=0;i<chars.length;i++){
            System.out.println(chars[i]);
        }
        System.out.println("----------------");
        String s3 = new String(chars);
        System.out.println(s3);
    }
}

/*
输出：
a
b
c
d
e
f
g
----------------
abcdefg
*/

static String valueOf(char[] chs)

//将字符数组转字符串

public class StringDemo5 {
    public static void main(String[] args) {
        String s1 = "abcdefg";
        char[] chars = s1.toCharArray();
        String s2 = String.valueOf(chars);
        System.out.println(chars);
        System.out.println(s2);
    }
}

/*
输出：
abcdefg
abcdefg
*/

static String valueOf(int i)

//将整数型转化为字符串

public class StringDemo5 {
    public static void main(String[] args) {
        System.out.println(String.valueOf(100));
    }
}

/*
输出：
100
*/

String toLowerCase()

//转小写

public class StringDemo5 {
    public static void main(String[] args) {
        String s4 = "HellOWOrlD";
        String res1 = s4.toLowerCase();
        System.out.println(res1);
    }
}

/*
输出：
helloworld
*/

String toUpperCase()

//转大写

public class StringDemo5 {
    public static void main(String[] args) {
        String s4 = "HellOWOrlD";
        String res2 = s4.toUpperCase();
        System.out.println(res2);
    }
}

/*
输出：
HELLOWORLD
*/

String concat(String str)

//字符串拼接操作

public class StringDemo5 {
    public static void main(String[] args) {
        String res3 = "李刚".concat("真帅！");
        System.out.println(res3);
    }
}

/*
输出：
李刚真帅！
*/

6、String其它功能

1、替换功能

String replace(char old,char new)
String replace(String old,String new)

String replace(char old,char new)

//由新字符替换字符串中所有旧字符

public class StringDemo6 {
    public static void main(String[] args) {
        String s1 = "dasqwajavadwqrajjavaiojadjavafq-aedjavaqajiqa";
        String res1 = s1.replace('a', '$');
        System.out.println(s1);
        System.out.println(res1);
    }
}

/*
输出：
dasqwajavadwqrajjavaiojadjavafq-aedjavaqajiqa
d$sqw$j$v$dwqr$jj$v$ioj$dj$v$fq-$edj$v$q$jiq$
*/

String replace(String old,String new)

//由新的字符串替换旧的字符串

public class StringDemo6 {
    public static void main(String[] args) {
        String s1 = "dasqwajavadwqrajjavaiojadjavafq-aedjavaqajiqa";
        String res2 = s1.replace("java", "李刚");
        System.out.println(s1);
        System.out.println(res2);
    }
}

/*
输出：
dasqwajavadwqrajjavaiojadjavafq-aedjavaqajiqa
dasqwa李刚dwqraj李刚iojad李刚fq-aed李刚qajiqa
*/

2、去除字符串两空格

String trim()

public class StringDemo6 {
    public static void main(String[] args) {
        String s2 = "    hello  world    ";
        System.out.println("s2: "+s2);
        String res3 = s2.trim();
        System.out.println("res3: "+res3);
    }
}

/*
输出：
s2:     hello  world    
res3: hello  world
*/

3、按字典顺序比较两个字符串

int compareTo(String str)
int compareToIgnoreCase(String str)

int compareTo(String str)

//按字典顺序比较两个字符串是否相同 当结果是0的时候表示两个字符串内容相同

public class StringDemo6 {
    public static void main(String[] args) {
        String s3 = "hello";
        String s4 = "world";
        String s5 = "hel";
        String s6 = "hello";
        System.out.println(s3.compareTo(s4));
        System.out.println(s3.compareTo(s5));
        System.out.println(s3.compareTo(s6));
    }
}

/*
输出：
-15
2
0
*/

String类中compareTo源码解释

class String{
    //s3.compareTo(s4)
    //s3 - "hello"
    //s4 - "hel"
    public int compareTo(String anotherString) {
        // this - "hello"
        // anotherString - "hel"
        int len1 = this.value.length; // 5
        int len2 = anotherString.value.length; // 3
        int lim = Math.min(len1, len2); // 3
        char[] v1 = value; // ['h','e','l','l','o']
        char[] v2 = anotherString.value; // ['h','e','l']
        int k = 0;

        while (k < lim) {
            char c1 = v1[k]; // 'h'  'e'  'l'
            char c2 = v2[k]; // 'h'  'e'  'l'
            if (c1 != c2) {
                return c1 - c2; // 104 - 119 = -15
            }
            k++;
        }
        return len1 - len2; // 5-3=2
    }
}

标签：Java,String,int,System,初学,day10,println,public,out
From： https://www.cnblogs.com/qianzhiqiang798/p/18438569

Java 初学 day10

Java 10

常用类

1、API概述

2、Object类

1、概述

2、构造方法

3、Object类的成员方法

一个标准类的4.0写法

拷贝又分为浅拷贝和深拷贝

浅拷贝 (Shallow Copy)

深拷贝 (Deep Copy)

3、scanner类

概述

构造方法

4、String类

1、概述

2、String类常用的构造方法

public String()

public String(byte[] bytes)

public String(byte[] bytes,int index,int length)

public String(char[] value)

public String(char[] value,int index,int length)

public String(String original)

3、String类常用的判断功能

boolean equals(Object obj)

boolean equalsIgnoreCase(String str)

boolean contains(String str)

boolean startsWith(String str)

boolean endsWith(String str)

boolean isEmpty()

4、String类中的获取功能

int length()

char charAt(int index)

int indexOf(int ch)

int indexOf(int ch,int fromIndex)

int indexOf(String str)

int indexOf(String str,int fromIndex)

String substring(int start)

String substring(int start,int end)

5、String转换功能

byte[] getBytes()

char[] toCharArray()

static String valueOf(char[] chs)

static String valueOf(int i)

String toLowerCase()

String toUpperCase()

String concat(String str)

6、String其它功能

1、替换功能

String replace(char old,char new)

String replace(String old,String new)

2、去除字符串两空格

3、按字典顺序比较两个字符串

int compareTo(String str)

String类中compareTo源码解释

相关文章

赞助商

阅读排行