JavaSE 进阶 (4) API

1
2
3
4
5
6
7
8

//1.导包->放在类的上边
import java.util.Random;

//2.创建对象->放在main方法中
Random r = new Random();

//3.产生随机数->放在创建对象的后边(随机范围是"0-数字"之间，包含0，不包含"数字")
int num = r.nextInt(数字)；

1
2
3
4
5
6
7

//假设 x < y

//产生x->y之间的随机数，包含x,不包含y
int num = r.nextInt(y-x)+x;  //[0, y-x) -> [0,y)

//产生x->y之间的随机数，包含x,包含y
int num = r.nextInt(y-x+1)+x;  //[0, y-x+1) -> [0, y+1)

1
2
3
4
5
6

public class Demo {
  public static void main(String[] args) {
    student s = new Student("张三"，23);
    System.out.println(s);  //com.itheima.demo1.Student@3f3afe78
  }
}

1
2
3
4
5
6
7

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

1
2
3
4
5

[I@10f87f48:
	[：当前的空间是一个数组类型
	@: 分隔符
	I: 当前数组容器中所存储的数据类型
	18f87f48：片进制内存地址

1
2
3
4
5
6
7
8

public static void main(String[] args) {
	Student s1 = new Student("zhangsan", 23);
	Student s2 = new Student("zhangsan", 23);
	
	System.out.println(s1 == s2);//false
	//object类中的equals方法，底层也是用==号比较地址值。
	System.out.println(s1.equals(s2));//false
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@override
public boolean equals(object o) {
	if (this == o) return true;
	if (o == null || getClass() != o.getClass()) return false;

	Student student = (Student) o;

	if (age != student.age) return false;
	return name != null ? name.equals(student.name) : student.name == null;
}

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

public class InterviewTest {
	public static void main(String[] args) {
		String s1 = "abc";
		StringBuilder sb = new StringBuilder("abc");
		//1.此时调用的是string类中的equals方法。
		//保证参数也是字符串，否则不会比较属性值而直接返回false,sb不是字符串,直接返回false
		//system.out.println(s1.equals(sb));

		//StringBuilder类中是没有重写equals方法，用的就是object类中的equals方法
		//object类中的equals方法：基本数据类型比较数据值，引用数据类型比较地址值，地址值不同，返回false
		system.out.println(sb.equals(s1)); //false
	}
}

 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

public class Student {
	......
	
	@Override
	public string tostring(){
		System.out.println("看看我执行了吗?")；
		return "Student{"+
			"name='" + name +'\''+
			", age=" + age +
			'}';
	}
}
--------------------------------------------------
public class MyObjectsDemo {
	public static void main(String[] args) {
		Student s = new Student("小罗同学"，50);
		String result = Objects.toString(s);
		System.out.println(result);
		/**
		 * 看看我执行了吗?
		 * Student{name='小罗同学'，age=50}
		 */
		
		System.out.println(s);
		/**
		 * 看看我执行了吗?
		 * Student{name='小罗同学'，age=50}
		 */
	}
}

1
2
3
4
5
6
7
8
9

public class Foo {
	private List<Bar> bars;
	
  public Foo(List<Bar> bars) {
		// 在此对入参进行校验
    	Objects.requireNonNull(bars, "bars must not be null");
	    this.bars = bars;
	}
}

1
2
3

Exception in thread "main" java.lang.NullPointerException: 不能为空
    at java.base/java.util.Objects.requireNonNull(Objects.java:228)
    at com.example.Main.main(Main.java:5)

1
2
3
4
5

public class MyBigDecimalDemo {
	public static void main(string[] args) {
		System.out.println(10.0 / 3.0);  //3.3333333333333335
	}
}

1
2
3
4
5
6
7
8

public class MyBigDecimalDemo2 {
	public static void main(String[] args) {
		BigDecimal bd1 = new BigDecimal(10.0);
		BigDecimal bd2 = new BigDecimal("0.3");
		System.out.println(bd1);  //10
		System.out.println(bd2);  //0.3
	}
}

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

public static void main(String[] args) {
	BigDecimal bd1 = new BigDecimal("0.1");
	BigDecimal bd2 = new BigDecimal("0.2");
	BigDecimal add = bd1.add(bd2);

	System.out.println(add);  //0.3
	System.out.println(0.1 + 0.2);  //0.30000000000000004
	
	//divide
	double v = BigDecimal.valueOf(100).divide(BigDecimal.valueOf(3), 1, BigDecimal.ROUND_HALF_UP).doubleValue();
	
	//setScale
	BigDecimal bigDecimal = BigDecimal.valueOf(100).setScale(1, BigDecimal.ROUND_HALF_UP);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class MyIntegerDemo1 {
	public static void main(String[] args){
		//需求：我要判断一个整数是否在int范围内？
		//Integer
		System.out.println(Integer.MAX_VALUE);  //2147483647
		System.out.println(Integer.MIN_VALUE);  //-2147483648
		
		//Byte、Short、Integer、Long、Float、Double 都有 MAX_VALUE 和 MIN_VALUE 方法，
	}
}

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

public class TestWraperclass {
	public static void main(String[] args) {
		//基本数据类型转为对象
		Integer i = new Integer(300);
		Integer i2 = Integer.valueof(20);
		
		//包装类对象转为基本数据类型
		double d = i2.doubleValue();
		
		//将字符串数字转成包装类对象
		Integer i3 = Integer.valueof("234");
		Integer i4 = Integer.parseInt("334");
		
		//将包装类对象转成字符串
		String str = i3.toString();
	}
}

1
2
3
4
5

ArrayList<Integer> List = new ArrayList();
List.add(10);
List.add(10);
List.add(10);
List.add(10);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

		//public Integer(int value) 根据int创建Integer对象（过时）
		//public Integer(string s)  根据string值创建Integer对象（过时）
		Integer i1 = new Integer(100);
		Integer i2 = new Integer("100");
		System.out.println(i1);
		System.out.println(i2);
		
		

		//public static Integer valueof (int i)    返回表示指定的int值的Integer实例

		//public static Integer valueof(String s)  返回一个保存指定值的Integer对象String
		Integer i3 = Integer.valueof(200);
		Integer i4 = Integer.valueof("200");
		System.out.println(i3);

		system.out.println(i4);
	}
}

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

public class MyIntegerDemo3 {
	public static void main(String[] args) {
		Integer i1 = 100;
		//对象 = 默认是一个基本数据类型
		//jdk1.5的特性 -- 自动装箱

		//装箱：把一个基本数据类型变量对应的包装类，
		//自动：Java底层会帮我们自动的调用valueof方法，
		System.out.println(i1);

		//jdk1.5的特性 -- 自动拆箱
		//拆箱：把一个包装类型变成对应的基本数据类型
		int i2 = i1;
		System.out.println(i2);
	}
}

1
2
3
4
5
6

Integer c = null;

//编译器帮你改成：c.intValue();
int c2 = c;

//java.1ang.NullPointerException: 对象为null，我们调用了他的属性或方法，c是空的.，c.intValue()调不了方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class MyIntegerDemo4 {
	public static void main(String[] args) {
		String s1 = "100";
		int i1 = 200;
		System.out.println(s1 + i1); //100200 -- 字符串+任意的数据类型结果都是一个字符串

		int i2 = Integer.parseInt(s1); //可以将字符串类型的整数变成int类型的整数
		System.out.println(i2 + i1);  //300

		//int --> string
		//方式一：+ ""
		int i3 = 100;
		String s2 = i3 + "";
		System.out.println(s2 + 100);  //100100

		//方式二：可以调用string类中valueof方法
		String s3 = String.valueof(i3);
		System.out.println(s3 + 100);  //100100
	}
}

 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

public class MyIntegerDemo5 {
	//需求：有一个字符串：“91 27 46 38 50”，把其中的每一个数存到int类型的数组中
	//步骤：
	//定义一个字符串
	//把字符串中的数字数据存储到一个int类型的数组中
	//遍历数组输出结果
	public static void main(String[] args) {
		String s = "91 27 46 38 50";
		//获取字符串中的每一个数字，
		String[] strArr = s.split(" ");
		
		//创建一个int类型的数组。
		int[] numberArr = new int[strArr.length];

		//把strArr中的数据进行类型转换并存入到int数组中
		for (int i = 0; i < strArr.length; i++){
			int number = Integer.parseInt(strArr[i]);
			numberArr[i]=number;
		}
	
		//遍历int类型的数组
		for (int i = 0; i < numberArr.length; i++){
			System.out.println(numberArr[i]);
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class MyFactorialDemo2 {
	public static void main(String[] args) {
		int sum = getsum(100);
		System.out.println(sum);
	}


	private static int getsum(int i) {
		//方法的作用：求1-100之间和
			// 100 + (1-99之间和)
				//...
					//1
		if(i == 1){
			return 1;
		}else{
			return i + getsum(i-1);
		}
	}
}

1
2
3
4
5
6
7

public static long factorial(int num) {
        if(num == 1){//递归头
            return 1;
        }else{//递归体
            return num * factorial(num - 1);  //n * (n - 1)
        }
}

1
2
3
4
5
6
7

int x = 10;
int sum = 1;
while(x > 1){
	sum *= x * (x - 1);
	x -=2;
}
System.out.println(sum);

1
2
3
4
5
6
7
8

public class Example {  
    public static void main(String[] args) {  
        int age = 25;  
        String name = "John";  
          
        System.out.println("年龄是%d岁，姓名是%s。", age, name);  //年龄是25岁，姓名是John。
    }  
}

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

public static long fs(long num) {
    if(num == 0 || num==1){
        return num;
    }else{
        return (fs(num - 1) + fs(num - 2));
    }
 }

public static void main(String[] args) {
    for(int count = 0;count <= 10;count ++){
		System.out.printf("斐波那契数列第%d个数为%d%n", count, fs(count));
	}
}

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

public static void main(string[] args) {
	//思考：控制台为什么会有这样的红色字体呢？是谁打印的？
	int[] arr = {1, 2, 3, 4, 5};
	System.out.printIn(arr[10]); //当代码出现了异常，那么就在这里创建了一个异常对象。
								//new ArrayIndexoutofBoundsException();
								//首先会看，程序中有没有自己处理异常的代码。
								//如果没有，交给本方法的调用者处理，
								//最终这个异常会交给虚拟机默认处理，
								//JVM默认处理异常做了哪几件事情：
								//1,将异常信息以红色字体展示在控制台上。
								//2,停止程序运行，--哪里出现了异常，那么程序就在哪里停止，下面的代码不执行
	System.out.println("嘿嘿嘿，我最帅")；
}

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

public class ExceptionDemo6 {
	public static void main(string[] args) {
		method1();  //此时调用者也没有处理。还是会交给虚拟机处理。虚拟机会采取默认处理异常的方法
	}

	//告诉调用者，你调用我，有可能会出现这样的异常哦，
	//如果方法中没有出现异常，那么正常执行
	//如果方法中真的出现了异常，其实也是将这个异常交给了调用者处理,调用者是method1()
	private static void method1() throws NullPointerException{
		int[] arr = null;
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}
}

1
2
3
4
5
6

private static void method1() /*throws NullPointerException*/ {
	int[] arr = null;
	for (int i = 0; i < arr.length; i++) {
		System.out.println(arr[i]);
	}
}

1
2
3
4

private static void method2() throws ParseException {
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
	sdf.parse("2048-10月10日");
}

1
2
3
4
5
6
7
8
9

public void setAge(int age) {
	if (age > 0 & age < 120) {
		this.age =age;
	}else{
		//System.out.println("年龄错误！！!");
		RuntimeException re = new RuntimeException("年龄异常");
		throw re;
	}
}

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

public class ExceptionDemo7 {
	public static void main(String[] args) {
		System.out.println("家里有一个貌美如花的老婆");
		System.out.println("还有一个当官的兄弟");
		System..out.println("自己还有一个买卖");
		System,out.println("这样的生活你要不要？");
		throw new RuntimeException();//当代码执行到这里，就创建一个异常对象
									//该异常创建之后，暂时没有手动处理。抛给了调用者处理
									//下面的代码不会再执行了
		System.out.println("武太郎的标准生活");
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class ExceptionDemo8 {
	public static void main(String[] args) {
		int[] arr = null;
		printArr(arr);  //这里就会接收到一个异常,这里没有处理,就会继续抛给调用者虚拟机,虚拟机采用默认的处理方法
						//我们还需要自己处理一下异常。该怎么处理呢? try...catch
	}
	
	private static void printArr(int[] arr) {
		if(arr == null) {
			//调用者知道成功打印了吗？结果显示在控制台,调用者不知道执行的结果,所以不能用打印的方式
			//System.out.println("参数不能为null");
			throw new NullPointerException();    //当参数为null的时候
												//手动创建一个异常对象，抛给了调用者
		} else {
			for (int i=0;i<arr.length;i++) {
				System.out.println(arr[i]);
			}
		}
	}
	
}

1
2
3
4
5

try {
	//可能出现异常的代码;
} catch (异常类名 变量名) {
	// 异常的处理代码;
}

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

public class ExceptionDemo9 {
	public static void main(String[] args) {
		//好处：为了能让代码继续往下运行
		int[] arr = null;
		try {
			//有可能发现异常的代码
			printArr(arr);
		} catch (NullPointerException e) {
			//如果出现了这样的异常，那么我们进行的操作
			System.out.println("参数不能为null");
			System.out.println("嘿嘿嘿，我最帅！I!");
		}
	}
}

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

public class ExceptionDemo11 {
	public static void main(String[] args) {
		try {
			int[] arr = {1, 2, 3, 4, 5};
			System.out.println(arr[10]);
			//在这里,虚拟机帮我们创建了一个异常对象 new ArrayIndexoutofBoundsException,然后将他赋值给了e
		} catch (ArrayIndexoutofBoundsException e) {
			//e.getMessage(): Index 10 out bounds for length 5
			System.out.println(e.getMessage());
			
			//e.toString(): java.lang.ArrayIndexOutOfBoundsException: Index 10 out bounds for length 5
			System.out.println(e.toString());
			e.printstackTrace();
		}
	}
}

 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

public class Student {
	private Integer age;

	......
	
	public void setAge(int age) {
		if (age>=18 && age<=25) {
			this.age = age;
		} else {
			throw new RuntimeException("年龄超出了范围");
		}
	}
}

public class TestDemo {
	public static void main(String[] args) {
		Student s = new student();
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入姓名");
		String name = sc.nextLine();
		s.setName(name);
		while (true) {
			System.out.println("请输入年龄");
			String agestr = sc.nextLine();
			try {
				int age = Integer.parseInt(agestr);
				s.setAge(age);
				break;
			} catch (NumberFormatException e) {
				System.out.println("请输入一个整数");
				continue;
			} catch (RuntimeException e) {
				System.out.println("请输入一个符合范围的年龄");
				continue;
		}
		System.out.println(s);
	}
}

 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

public class Student {
	private Integer age;
	
	......
	public void setAge(int age) {
		if (age>=18 && age<=25) {
			this.age = age;
		} else {
			//自定义异常的目的：为了让异常信息更加的见名知意
			//throw new runtimeException("年龄超出了范围"):
			hrow new AgeoutofBoundsException("年龄超出了范围")；
		}
	}
	
}

public class TestDemo {
	public static void main(String[] args) {
		Student s = new student();
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入姓名");
		String name = sc.nextLine();
		s.setName(name);
		while (true) {
			System.out.println("请输入年龄");
			String agestr = sc.nextLine();
			try {
				int age = Integer.parseInt(agestr);
				s.setAge(age);
				break;
			} catch (NumberFormatException e) {
				System.out.println("请输入一个整数");
				continue;
			} catch (AgeoutofBoundsException e) {
				System.out.println("请输入一个符合范围的年龄");
				continue;
		}
		System.out.println(s);
	}
}