Java常用类和对象---尚硅谷Java入门视频学习

1.Object

常用方法：

• toString() 将对象转换成字符串。
  toString默认打印的就是对象的内存地址，所以，为了能够更直观理解对象的内容，可以重写这个方法

• hashCode() 获取对象的内存地址

• equals() 判断两个对象是否相等, 如果相等，那么返回true，否则返回false
  equals方法比较对象时，默认比较就是内存地址

• getClass()获取对象的类型信息

Class<?> aClass = obj.getClass();
System.out.println(aClass.getSimpleName()); //类名
System.out.println(aClass.getPackageName());//包名
1
2
3

2.数组

• 数组的声明方式：类型[] 变量；

• 数组的创建：new 类型[容量]；

int[] arr = new int[]{1,2,3};
String[] names = new String[3];
1
2

冒泡排序

从所有数据中找出数据的最大值，将最大值放置数组的最后；缩小查找的范围，将最大值放在最后，以此类推，完成数组的排序。
第一轮循环比较


第一轮循环，比较五个数，将五个数中最大值放在最后；
第二轮循环，比较前四个数，将四个数中最大值放在最后；
…

	int[] nums = {1,4,3,5,2};
        // TODO 希望获取到的数据，1，2，3，4，5
        // 简化需求：将数组中的最大值放置数组的最后
        for ( int j = 0; j < nums.length; j++ ) {
            for ( int i = 0; i < nums.length - j - 1; i++ ) {
                //每一轮 相邻的两个数
                int num1 = nums[i];
                int num2 = nums[i+1];
                if ( num1 > num2 ) {
                    // 左边的数据大于右边的数据，应该交互位置
                    nums[i] = num2;
                    nums[i+1] = num1;
                }
            }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

选择排序

从数组中任意选择一个数，当做数组的最大值保存其索引；与后面的数进行比较，若后面的数比这个数大，则更新最大值索引，完成一轮比较，将最大值与最后面的值进行交换。缩小查找的范围，进行比较，以此类推，完成数组的排序。
每一轮循环，只有最后一次需要交换数据。

	 int[] nums = {1,4,3,5,2};
        for ( int j = 0; j < nums.length; j++ ) {
            int maxIndex = 0;//默认第一个值最大
            for ( int i = 1; i < nums.length - j; i++ ) {
                if ( nums[i] > nums[maxIndex] ) {  //每一轮循环 从第二个数开始，与最大值比较
                    maxIndex = i;  //改变最大值索引
                }
            }
            int num1 = nums[nums.length-j-1]; //最后一个数
            int num2 = nums[maxIndex];//单次循环 最大值

            nums[maxIndex] = num1;  //交换
            nums[nums.length-j-1] = num2;
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.字符串String

String name1 = "zhangsan";
String name2 = new String("zhangsan");
1
2

• 字符数组变成字符串

char[] cs = {'a', '中', '国'};
String s = new String(cs);

//        
//
//        
//        
1
2
3
4
5
6
7

• 字节数组变成字符串

byte[] bs = {-28,-72,-83,-27,-101,-67};
String s1 = new String(bs, "UTF-8");  //中国
1
2

UTF-8编码：一个英文字符等于一个字节，一个中文（含繁体）等于三个字节。

• 转义字符

String s = "\"";
System.out.println(s);     // "
System.out.println("\'");  // '
System.out.println("a\tb");// a	b


System.out.println("c\nd");// c  （换行）d
System.out.println("e\\f");//e\f     \\表示\本身
1
2
3
4
5
6
7
8

• 字符串的比较

 String a = "a";
 String b = "A";
相等
  System.out.println(a.equals(b));  //false
  // 忽略大小写的相等
  System.out.println(a.equalsIgnoreCase(b)); //true
比较
 // i = 正数，a > b
 // i = 负数，a < b
 // i = 0, a = b
 int i = a.compareTo(b);
 System.out.println(i); //32     A 65  a 97
 // 忽略大小写的比较
 System.out.println(a.compareToIgnoreCase(b));  //0
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 字符串的截取
  substring方法用于截取字符串，需要传递两个参数，
  第一个参数表示截取字符串的起始位置（索引，包含）
  第二个参数表示截取字符串的结束位置（索引，不包含）
  如果只传递一个参数，那么就表示从指定位置开始截取字符串，然后截取到最后

String s = "  Hello World";
System.out.println(s.substring(0, "Hello".length()));  //Hello
1
2

分解字符串 ：根据指定的规则对字符串进行分解。可以将一个完整的字符串，分解成几个部分。

String s = "  Hello World";
String[] s1 = s.split(" ");
System.out.println(s1.length);//2
for (String s2 : s1) {
	System.out.println(s2);  //Hello (换行) World
}
1
2
3
4
5
6

trim() : 去掉字符串的首尾空格

• 字符串的替换

String s = "Hello World zhangsan"; 
// 替换
System.out.println(s.replace("World zhangsan", "Java"));  // Hello Java
// replaceAll按照指定的规则进行替换
System.out.println(s.replaceAll("World|zhangsan", "Java"));// Hello Java Java 将World或者zhangsan替换成Java
1
2
3
4
5

• 字符串的大小写转换

String s = "Hello World";
System.out.println(s.toLowerCase());  //hello world
System.out.println(s.toUpperCase());  //HELLO WORLD
1
2
3

• 字符串的查找

 String s = "Hello World";
char[] chars = s.toCharArray();  //字符数组
byte[] bytes = s.getBytes("UTF-8"); //字节码
//charAt可以传递索引定位字符串中指定位置的字符
System.out.println(s.charAt(1));  //e
//indexof方法用于获取数据在字符串中第一次出现的位置。
System.out.println(s.indexOf("World"));  //6
// lastIndexOf方法用于获取数据在字符串中最后一次出现的位置。
String s1 = "World Hello World";
System.out.println(s1.lastIndexOf("World")); //12
// 是否包含指定的字符串，返回布尔类型
System.out.println(s.contains("Hello123")); //false
// 判断字符串是否以指定的数据开头，返回布尔类型
System.out.println(s.startsWith("Hello")); //true
// 判断字符串是否以指定的数据结尾，返回布尔类型
System.out.println(s.endsWith("World")); //true
// 判断字符串是否为空，空格其实是一个特殊的字符，所以看不到，但是不为空。
System.out.println(s.isEmpty());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• StringBuilder

StringBuilder s = new StringBuilder();
s.append("abc");
System.out.println(s.toString());
System.out.println(s.length());
System.out.println(s.reverse()); // 反转字符串 cba
System.out.println(s.insert(1, "d")); //cdba
1
2
3
4
5
6

4.包装类

int i = 10;
Integer i1 = new Integer(i);
//将基本数据类型转换为包装类型
// 自动装箱
//Integer i1 = Integer.valueOf(i);
Integer i1 = i;
// 自动拆箱
int i2 = i1.intValue();
int i2 = i1;
1
2
3
4
5
6
7
8
9

5.日期类

时间戳 ： 毫秒

 System.currentTimeMillis()
1

• 日期类

// Date : 日期类
Date d = new Date();
// Java格式化日期格式：
// y (Y) -> 年 -> yyyy
// m (M) -> MM : 月份，mm:分钟
// d (D) -> dd : 一个月中的日期，D：一年中的日期
// h (H) -> h : 12进制， HH：24进制
// s (S) -> s : 秒，S :毫秒
// Date -> String
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat sdf2 = new SimpleDateFormat( pattem: "yyyy-MM-dd HH:mm:ss.SSS")
String dateFormatString = sdf.format(d);
System.out.println(dateFormatString);
// String -> Date
String dateString = "2022-06-01";
Date parseDate = sdf.parse(dateString);
System.out.println(parseDate);
// 根据时间戳构建指定的日期对象。
d.setTime(System.currentTimeMillis());
// 获取时间戳
d.getTime();
System.out.println(parseDate.before(d));  //判断两个时间
System.out.println(parseDate.after(d));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• 日历类

 // 日历类
//获取当前日期的日历对象
Calendar instance = Calendar.getInstance();
System.out.println(instance.get(Calendar.YEAR));
System.out.println(instance.get(Calendar.MONTH));  //月份 从0开始 如十月返回9
System.out.println(instance.get(Calendar.DATE));
System.out.println(instance.get(Calendar.DAY_OF_WEEK)); // 当前日期是周几
System.out.println(instance.get(Calendar.DAY_OF_MONTH)); // 当前日期是几号
instance.setTime(new Date());
instance.add(Calendar.YEAR, -1);  //当前日期减一年
1
2
3
4
5
6
7
8
9
10

6.异常

异常 ： Exception
异常的分类

• 1.可以通过代码恢复正常逻辑的异常,称之为运行期异常。（RuntimeException）

• 2.不可以通过代码恢复正常逻辑的异常,称之为编译期期异常(Exception)
  异常处理语法：

    try :尝试
    catch :  捕捉
       捕捉多个异常的时候，需要先捕捉范围小的异常，然后再捕捉范围大的异常
    finally : 最终
    try {
        可能会出现异常的代码
        如果出现异常，那么JVM会将异常进行封装，形成一个具体的异常类，然后将这个异常抛出
        所有的异常对象都可以被抛出
    } catch ( 抛出的异常对象 对象引用 ) {
        异常的解决方案
    } catch () {
  
    } finally {
       最终执行的代码逻辑
    }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

//如果方法中可能会出现问题，那么需要提前声明，告诉其他人，我的方法可能会出问题。
// 此时需要使用关键字throws 明确方法会抛出异常
//如果程序中需要手动抛出异常对象，那么需要使用throw关键字，然后new出异常对象
 public static void test( int i, int j ) throws Exception {
        try {
            System.out.println(i / j);
        } catch (ArithmeticException e) {
            throw new Exception("除数为0");
        }

    }
1
2
3
4
5
6
7
8
9
10
11

自定义异常

public class Java08_Exception {
    public static void main(String[] args) throws Exception {

        String account = "zhangsan";
        String password = "123123";
        try {
            login(account, password);
        } catch (AccountException accountException) {
            System.out.println("账号不正确，需要重新修正");
        } catch (PasswordException passwordException) {
            System.out.println("密码不正确，需要重新修正");
        } catch (LoginException loginException) {
            System.out.println("其他登录相关的错误");
        }


    }

    public static void login(String account, String password) {
        if (!"admin".equals(account)) {
            throw new AccountException("账号不正确");
        }
        if (!"admin".equals(password)) {
            throw new PasswordException("密码不正确");
        }
        System.out.println("登陆成功");
    }

}

// TODO 自定义异常
class LoginException extends RuntimeException {
    public LoginException(String message) {
        super(message);
    }
}

class AccountException extends LoginException {
    public AccountException(String message) {
        super(message);
    }
}

class PasswordException extends LoginException {
    public PasswordException(String message) {
        super(message);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49