Java基础第五天

１、字符串对象的4种构造方法

public class Demo01String {
　　public static void main(String[] args) {
　　　　//第一种构造方法，参数留空。
　　　　String str1 = new String();
　　　　System.out.println(“第一个字符串为” + str1);
　　　　//第二种构造方法，参数为char数组。
　　　　char[] charArray = new char[] { ‘A’, ‘B’, ‘C’ };
　　　　String str2 = new String(charArray);
　　　　System.out.println(“第二个字符串为” + str2);
　　　　//第三种构造方法，参数为byte数组。字节是计算机存储数据的最小单位。任何数据都是由字节构成的。
　　　　byte[] byteArray = new byte[] { 97, 98, 99 };
　　　　String str3 = new String(byteArray);
　　　　System.out.println(“第三个字符串为” + str3);
　　　　//直接创建,没有new也是字符串类的对象，JVM帮我们new了
　　　　String str4 = “Hello”;
　　　　System.out.println(str4);
　　}
}

２、字符串常量池

public class Demo02StringPool {
　　public static void main(String[] args) {
　　　　//直接用双引号创建的字符串才会字符串常量池中。字符串常量池在堆内存中。
　　　　//字符串常量池中的字符串对象会用底层的byte数组进行表示，所以字符串对象保存的是byte数组的地址值。
　　　　//字符串常量池中的字符串对象的地址值会保存在对应的字符串变量名，如str1中。
　　　　//所以str1保存字符串常量池中字符串对象的地址值，找到字符串对象，然后通过字符串对象保存的char数组地址值找到char数组。
　　　　String str1 = “abc”;
　　　　String str2 = “abc”;//str2发现字符串常量池中有对应的"abc"，就直接存储了池中的字符串对象的地址值。所以和str1存储的地址一样。
　　　　char[] charArray = new char[] { 97, 98, 99 };//new的char数组在堆中，但不在池中。
　　　　String str3 = new String(charArray);//new的字符串对象在堆中但不在池中，先将char数组转换为byte数组，然后堆中的字符串对象存储byte数组的地址值，str3存储堆中字符串对象的地址值。
　　　　//引用类型的==是地址值的比较
　　　　System.out.println(str1 == str2);//true
　　　　System.out.println(str1 == str3);//false
　　　　System.out.println(str2 == str3);//false
　　}
}

３、字符串的常用方法

比较内容、获取长度、拼接、获取指定索引位置的单个字符、查找参数字符串在原来字符串中第一次出现的索引位置、截取字符串、字符串转换（char数组、byte数组、内容替换）、字符串分割
public class Demo03StringMethod {
　　public static void main(String[] args) {
　　　　//比较字符串内容是否相同
　　　　/*
　　　　String str1 = “Hello”;
　　　　String str2 = “Hello”;
　　　　char[] charArray = new char[] { ‘H’, ‘e’, ‘l’, ‘l’, ‘o’ };
　　　　String str3 = new String(charArray);
　　　　//比较字符串内容，使用//true方法。public boolean equals(Object obj)参数可以是任何对象，但只有参数是字符串且内容相同才会返回true。
　　　　System.out.println(str1.equals(str2));//true
　　　　System.out.println(str1.equals(str3));//true
　　　　System.out.println(str1.equals(“Hello”));//true 不推荐，如果str1为null，会报空指针异常。
　　　　System.out.println(“Hello”.equals(str1));//true 推荐将常量写在方法前。
　　　　String str4 = “hello”;
　　　　System.out.println(str1.equalsIgnoreCase(str4));//忽略大小写进行内容比较
　　　　/
　　　　//获取字符串长度
　　　　/
　　　　int length = “djcidjncjdhyehhcb”.length();
　　　　System.out.println(length);
　　　　/
　　　　//拼接字符串
　　　　/
　　　　String str1 = “Hello”;
　　　　String str2 = “World”;
　　　　String str3 = str1.concat(str2);//拼接后原来的字符串不会变，字符串一旦创建内容就不会改变。
　　　　System.out.println(str3);//HelloWorld
　　　　/
　　　　//获取指定索引位置的单个字符
　　　　/
　　　　char ch = “Hello”.charAt(1);//索引从0开始
　　　　System.out.println(ch);//e
　　　　*/

//查找参数字符串在原来字符串中第一次出现的索引位置，未出现返回-1
　　　　/*
　　　　int index = “HelloWorld”.indexOf(“llo”);
　　　　System.out.println(index);//2
　　　　/
　　　　//截取字符串
　　　　/
　　　　String str = “HelloWorld”;
　　　　String str1 = str.substring(5);//World 从参数截取到字符串末尾
　　　　String str2 =str.substring(4,7);//oWo 左闭右开
　　　　System.out.println(str1);
　　　　System.out.println(str2);
　　　　/
　　　　//字符串内容不会改变，一旦改变肯定是创建了新的字符串。
　　　　/
　　　　String str1 = “Hello”;//开始str1存储的是字符串"Hello"的地址值
　　　　System.out.println(str1);
　　　　str1 = “Java”;//现在str1存储的是字符串"Java"的地址值，字符串内容没有改变，改变的是str1存储哪个字符串的地址值。
　　　　System.out.println(str1);
　　　　/
　　　　//字符串转换
　　　　//转换为char数组
　　　　/
　　　　char[] charArray = “Hello”.toCharArray();
　　　　for (int i = 0; i < charArray.length; i++) {
　　　　　　System.out.println(charArray[i]);
　　　　}
　　　　System.out.println(charArray.length);//数组获取长度没有()
　　　　/
　　　　//转换为字节数组，常用于I/O流
　　　　/
　　　　byte[] byteArray = “Hello”.getBytes();
　　　　for (int i = 0; i < byteArray.length; i++) {
　　　　　　System.out.println(byteArray[i]);
　　　　}
　　　　System.out.println(byteArray.length);
　　　　/
　　　　//字符串内容替换
　　　　/
　　　　String str = “会不会玩啊？你大爷的！你大爷的！”;
　　　　String str1 = str.replace(“你大爷的”, “****”);
　　　　System.out.println(str1);
　　　　*/
　　　　//字符串分割
　　　　//split的参数是一个正则表达式，要根据.分割要写\.
　　　　String str = “aaa,bbb,ccc”;
　　　　String[] strs = str.split(",");
　　　　for (int i = 0; i < strs.length; i++) {
　　　　　　System.out.println(strs[i]);
　　　　}
　　}
}

４、字符串小练习

将数组按指定格式拼接成字符串
统计键盘输入的字符串中各种字符出现的次数（大写、小写、数字、其它）
public class Demo04StringPra {
　　public static void main(String[] args) {
　　　　//拼接练习
　　　　/*
　　　　int[] num = new int[] { 1, 2, 3 };
　　　　String str = concatString(num);
　　　　System.out.println(str);
　　　　*/
　　　　countChar();
　　}
　　//将数组按指定格式拼接成字符串
　　public static String concatString(int[] num) {
　　　　String str = “[”;//开始str存储"[“的地址值
　　　　for (int i = 0; i < num.length; i++) {
　　　　　　if (i == num.length - 1) {
　　　　　　　　str += “word” + num[i];//这里str存储拼接后的字符串的地址值，原先的”["字符串并没有改变，其空间也还在堆内存中等待回收。
　　　　　　} else {
　　　　　　　　str += “word” + num[i] + “#”;
　　　　　　}
　　　　}
　　　　str += “]”;
　　　　return str;
　　}
　　//统计键盘输入的字符串中各种字符出现的次数（大写、小写、数字、其它）
　　public static void countChar() {
　　　　int bigCount = 0, smallCount = 0, numCount = 0, elseCount = 0;
　　　　Scanner sc = new Scanner(System.in);
　　　　String str = sc.next();
　　　　char[] charArray = str.toCharArray();
　　　　for (int i = 0; i < charArray.length; i++) {
　　　　　　char ch = charArray[i];
　　　　　　if (ch >= ‘A’ && ch <= ‘Z’) {//char进行数学运算提升为int，也就是对应的ASCII值
　　　　　　　　bigCount++;
　　　　　　} else if (ch >= ‘a’ && ch <= ‘z’) {
　　　　　　　　smallCount++;
　　　　　　} else if (ch >= ‘0’ && ch <= ‘9’) {
　　　　　　　　numCount++;
　　　　　　} else {
　　　　　　　　elseCount++;
　　　　　　}
　　　　}
　　　　System.out.println(“大写字母：” + bigCount);
　　　　System.out.println(“小写字母：” + smallCount);
　　　　System.out.println(“数字：” + numCount);
　　　　System.out.println(“其它：” + elseCount);
　　}
}

５、static关键字

１、静态成员变量、静态成员方法及静态代码块
２、静态方法只能直接访问静态变量，不能直接访问非静态变量，因为在内存中，先有静态内容，再有非静态内容
３、静态方法不能使用this关键字，因为this表示当前对象，而静态方法属于类，和对象没有关系
４、静态代码块只有在第一次使用本类才会执行，只执行一次，且在构造方法之前执行
定义学生类
//静态内容在方法区内存的静态区中
public class Student {
　　static {
　　　　//静态代码块只有在第一次使用本类才会执行，只执行一次，且在构造方法之前执行
　　　　System.out.println(“静态代码块执行”);
　　}
　　private int id;
　　private String name;
　　private int age;
　　static String classroom;//共享classroom
　　static int idCounter = 0;//共享idCounter，所有每个对象的idCounter都一样，新建对象是基于此时的idCounter++自动定义学号
　　public Student() {
　　　　this.id = ++idCounter;
　　}
　　public int getId() {
　　　　return id;
　　}
　　public void setId(int id) {
　　　　this.id = id;
　　}
　　public Student(String name, int age) {
　　　　this.name = name;
　　　　this.age = age;
　　　　this.id = ++idCounter;
　　}
　　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 void normalMethod() {
　　　　System.out.println(“普通成员方法”);
　　　　System.out.println(name);//普通成员方法可以直接访问静态变量和非静态变量
　　　　System.out.println(classroom);
　　　　System.out.println(this);//输出的是当前对象的地址
　　}
　　public static void staticMethod() {
　　　　System.out.println(“静态成员方法”);
　　　　//System.out.println(name);//静态方法不能直接访问非静态变量，因为在内存中，先有静态内容，再有非静态内容
　　　　System.out.println(classroom);//静态方法可以直接访问静态变量
　　　　//System.out.println(this);//静态方法不能使用this关键字，因为this表示当前对象，而静态方法属于类，和对象没有关系
　　}
}
测试学生类
public class Demo01Static {
　　public static void main(String[] args) {
　　　　Student stu1 = new Student(“张三”, 18);
　　　　Student stu2 = new Student(“李四”, 20);
　　　　Student.classroom = “101教室”;//加了static的数据是所有类对象共享的，是属于类的,推荐用类名称调用静态变量
　　　　System.out.println(stu1.getId() + “,” + stu1.getName() + “,” + stu1.getAge() + “,” + stu1.classroom);
　　　　System.out.println(stu2.getId() + “,” + stu2.getName() + “,” + stu2.getAge() + “,” + stu2.classroom);
　　　　stu1.normalMethod();//普通成员方法用对象名称调用
　　　　//stu1.staticMethod();//不推荐用对象名称调用静态成员方法，编译后也会被javac翻译为用类名称调用静态成员方法
　　　　Student.staticMethod();//推荐用类名称调用静态成员方法，因为静态成员方法属于类，不属于对象，不用创建对象就可以调用
　　　　method();//调用本类内的静态方法，前面可以省略类名称，但编译后也会翻译为加上类名称
　　}
　　public static void method() {
　　　　System.out.println(“本类内方法”);
　　}
}

６、Arrays类的常用方法

１、Arrays是一个与数组相关的工具类，提供了大量静态方法
２、String toString(数组) 将数组转换为字符串，按照格式[元素1, 元素2, 元素3, …]
３、void sort(数组) 按照升序对数组元素进行排序 自定义的类的对象要进行排序，需要有Comparable或Comparator接口的支持
public class Demo01Arrays {
　　public static void main(String[] args) {
　　　　int[] arrays = { 10, 3, 8, 37, 98 };
　　　　String str = Arrays.toString(arrays);
　　　　System.out.println(str);//[10, 3, 8, 37, 98]
　　　　Arrays.sort(arrays);//没有返回值，直接对原数组进行排序
　　　　System.out.println(Arrays.toString(arrays));//[3, 8, 10, 37, 98]
　　　　String[] stringArray = {“bac”, “abc”, “cab”};//[abc, bac, cab] 字符串按照字母升序排序，中文按照对应的数值升序
　　　　Arrays.sort(stringArray);
　　　　System.out.println(Arrays.toString(stringArray));
　　}
}

７、Arrays类的小练习

将随便定义的一个字符串的字符升序排序，并逆序打印
public class Demo02ArraysPra {
　　public static void main(String[] args) {
　　　　String str = “436djcjsuhbakxhdnsjendu”;//数字的ASCII值在字母之前，所以升序在字母之前
　　　　sortString(str);
　　}
　　public static void sortString(String str) {
　　　　char[] charArray = str.toCharArray();
　　　　Arrays.sort(charArray);
　　　　System.out.println(Arrays.toString(charArray));//[3, 4, 6, a, b, c, d, d, d, e, h, h, j, j, j, k, n, n, s, s, u, u, x]
　　　　for (int i = charArray.length - 1; i >= 0; i–) {//数组名.fori是正序循环，.forr是倒序循环
　　　　　　System.out.println(charArray[i]);
　　　　}
　　}
}

８、Math类的常用方法

１、Math类是与数学运算相关的工具类，提提供了大量静态方法
２、double abs(double num) 绝对值
３、double ceil(double num) 向上取整 12.1->13 例：车每趟运10个箱子，一共21个箱子，要运21/10 = 2.1 = 3趟
４、double floor(double num) 向下取整 12.9->12 例：超市抹零
５、long round(double num) 四舍五入 小数变为整数
６、Math.PI 圆周率
public class Demo01Math {
　　public static void main(String[] args) {
　　　　System.out.println(Math.abs(-2.5));//2.5
　　　　System.out.println(Math.ceil(12.1));//13.0
　　　　System.out.println(Math.floor(12.9));//12.0
　　　　System.out.println(Math.round(12.4));//12
　　　　System.out.println(Math.round(12.5));//13
　　　　System.out.println(Math.PI);//3.141592653589793
　　}
}

９、Math类的小练习

计算在-10.8到5.9之间，绝对值大于6或小于2.1的整数有几个
public class Demo02MathPra {
　　public static void main(String[] args) {
　　　　System.out.println(getResult());
　　}
　　public static int getResult() {
　　　　int count = 0;
　　　　for (int i = (int)(Math.ceil(-10.8)); i < (int)(Math.floor(5.9)); i++) {
　　　　　　if (Math.abs(i) > 6 || Math.abs(i) < (int)(Math.ceil(2.1))) {
　　　　　　　　count ++;
　　　　　　　　System.out.println(i);
　　　　　　}
　　　　}
　　　　return count;
　　　　//老师的方法
　　　　/*
　　　　int count = 0;
　　　　double min = -10.8;
　　　　double max = 5.9;
　　　　for (int i = (int)min; i < max; i++) {//-10.8强转为int 舍弃小数位为10，i<max=5.9，而i是整数，所以i最大为5
　　　　　　int abs = Math.abs(i);
　　　　　　if (abs > 6 || abs < 2.1) {
　　　　　　　　count ++;
　　　　　　　　System.out.println(i);
　　　　　　}
　　　　}
　　　　*/
　　}
}