java学习之高级语法（一）----- 常用API

不知名架构师

619人浏览 · 2020-10-30 21:14:24

不知名架构师 · 2020-10-30 21:14:24 发布

API

▶ API：Application Programming Interface 应用程序编程接口

▶ Java API是一本程序员的“ 字典 ”，是JDK中提供的使用类的说明文档。类将底层的代码实现封装了起来，我们不需要关系类是怎么实现的，只需要学习怎么使用这些类即可。所以通过查询API就可以知道怎么使用它们。

▶ 在使用API查找到你想要的某个类时，需要关注以下几个部分：

（1）看包：看是否需要导包【注意：如果一个类是属于java.lang包下则不需要导包，其他需要导包】

（2）看类的解释和说明

（3）学习构造方法

（4）使用成员方法

Scanner类

▶ Scanner类的功能：可以实现键盘输入数据到程序当中

使用上面这段代码可以实现键盘输入，这里的System.in 目前可以看成是固定写法记住，System.in系统输入指的是通过键盘录入数据。

▶ 引用类型的一般使用步骤：

（1）导包

import 包名 . 类名称

【如果需要使用的目标类和当前类位于同一个包下，则可以省略导包语句不写。只有Java.lang包下的内容不需要导包，其他的包都需要import语句】

（2）创建

类名称对象名 = new 类名称() ；

（3）使用

对象名.成员方法( ) ；

获取键盘输入的一个int数字：int num = sc.nextInt();

获取键盘输入的一个字符串：String str = sc.next();

----- 例：键盘输入三个int数字，然后求出其中的最大值

import java.util.Scanner;

public class Demo03ScannerMax {

	public static void main(String[] args) {
		// 创建Scanner类的对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入第一个数字：");
		int a = sc.nextInt();
		System.out.println("请输入第二个数字：");
		int b = sc.nextInt();
		System.out.println("请输入第三个数字：");
		int c = sc.nextInt();
		
		// 用三元运算符
		int temp = a>b?a:b ;
		int max = temp>c?temp:c;
		System.out.println("最大值为："+max);
		
		
	}

}

【这里用三元运算符更简单一些，也可以用 if 语句来判断】

匿名对象（了解）

▶ 匿名对象的概念

之前创建对象的标准格式：类名称对象名称 = new 类名称() ;

匿名对象就是创建对象时，只有右边的对象，没有左边的名字和运算符，虽然是创建对象的简化写法，但是应用场景非常有限。

匿名对象创建格式： new 类名称() ;

▶ 匿名对象的应用

（1）创建匿名对象直接调用方法，没有变量名。

 new Scanner(System.in).nextInt();

（2）一旦调用两次方法就是创建了两个对象，造成浪费。

 new Scanner(System.in).nextInt();
 new Scanner(System.in).nextInt();

【注意：匿名对象只能使用唯一的一次，下次使用必须再创建一个新的对象】

【使用建议：如果确定有一个对象只需要使用唯一的一次，则可以用匿名对象】

（3）匿名对象可以作为方法的参数和返回值

import java.util.Scanner;

public class Demo01 {

	public static void main(String[] args) {
		
		// 普通方法
		Scanner sc = new Scanner(System.in);
		input(sc);
		
		// 匿名对象方法
		input(new Scanner(System.in));
		

	}
	
	public static void input(Scanner sc) {
		
		System.out.println(sc);
		
	}

}

Random类

▶ 作用：Random类用来生成随机数字

▶ 使用Random也是三个步骤：

（1）导包

import java.util.Random ;

（2）创建

Random r = new Random() ; // 小括号中留空

（3）使用

获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt() ;

获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3) ;

这里括号里的3表示 [ 0 , 3 ) ，也就是 0~2

（创建一个Random对象，每次调用nextInt()方法，都会生成一个随机数）

// 获取 [1,n] 范围内的一个随机数 
import java.util.Random
public class Demo01 { 
        
       public static void main(String[] args){

               int n = 50 ;
               
               // 创建对象
               Random r = new Random() ;

               // 获取随机数
               int number = r.nextInt(n)+1 ;

               // 输出随机数
               System.out.println( "number:" + number) ;
       }
}

// 不管在学习哪种编程语言，都见过这样一个猜数字的小游戏
import java.util.Random;
import java.util.Scanner;

public class Demo02 {

	public static void main(String[] args) {
		
		// 首先产生一个1-100的随机数作为答案
		Random n = new Random() ;
		int number = n.nextInt(100)+1;
		
		// 进入猜答案的循环，注意产生作为答案的数字的过程不能放在循环里面
		while(true) {
			
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入你要猜的数字(1-100)：");
			int guessNumber = sc.nextInt();
			
			// 比较所猜数字和答案是否一致
			if( guessNumber > number) {
				
				System.out.println("大了，再猜! ");
				
			}else if(guessNumber < number) {
				
				System.out.println("小了，再猜! ");
			}else if (guessNumber == number) {
				
				System.out.println("恭喜你，猜对啦!") ;
				break ;
				
			}
		}
	}
}

ArrayList集合

▶ 数组的长度是固定的，无法适应数据变化的需求，但是ArrayList集合的长度是可以随意变化的，这样可以更加便捷的存储和操作对象数据。

▶ 对于ArrayList来说，有一个尖括号 < E > 代表泛型

泛型：也就是装在集合当中的所有元素全都是统一的什么类型【泛型只能是引用类型，不能是基本类型】

注意：对于ArrayList集合来说，直接打印得到的不是地址值，而是内容

如果内容是空，则得到的是空的中括号 [ ]

▶ ArrayList当中的常用方法有：

1. public boolean add(E e) ：向集合中添加元素，参数的类型和泛型一致，返回值代表添加是否成功

2. public E get(int index) ：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素

3. public E remove(int index) ：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素

4. public int size() ：获取集合的尺寸长度，返回值是集合中包含的元素的个数

【数组的长度用length获取，而ArrayList集合的长度用size获取】

【注意：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用，但是对于其他集合来说，add添加动作不一定成功。】

如果希望向集合ArrayList当中存储基本数据类型，必须使用基本类型对应的 “ 包装类 ” 。

基本类型 ---> 包装类（引用类型，包装类都位于java.lang包下）：

从上面的表中我们可以看出只有 int 和 char 这两个基本类型的包装类型需要特别的记忆一下，其他都是把首字母变成大写。

// 存储基本类型数据的集合
import java.util.ArrayList ;
public class Demo03{

       public static void main(String[] args){

          ArrayList<Integer> list = new ArrayList<>();

          list.add(1) ;
          
          list.add(2) ;
    
          list.add(3) ;

          System.out.println(list) ;

       }
}

从JDK 1.5+开始，支持自动装箱、自动拆箱

自动装箱：基本类型 ----> 包装类型

自动拆箱：包装类型 ----> 基本类型

String类（字符串）

▶ java.lang.String 类代表字符串

API当中说：Java程序中所有的字符串字面值(如“abc”)都作为此类的实例实现

其实就是说：程序当中所有的双引号字符串，都是String类的对象（就算没有new，也照样是）

▶ 字符串的特点：

1. 字符串的内容永不可变

2. 正是因为字符串不可以改变，所以字符串是可以共享使用的

String s1 = " abc " ;
String s2 = " abc " ;
// 内存中只有一个“abc”对象被创建，同时被s1和s2共享

3. 字符串效果上相当于char[ ] 数组，但是底层原理是byte[ ] 字节数组

String str = "abc" ；

上面和下面这种形式是等价的

char[] data = { 'a' ,'b' , ' c' } ;
String str = new String(data) ;

▶ 创建字符串的常见3+1种方法(3中构造方法+1种直接创建)：

1. public String() ：创建一个空白字符串，不含有任何内容

2. public String(char[ ] array) ：根据字符数组的内容，来创建对应的字符串

3. public String(byte[ ] array) ：根据字节数组的内容，来创建对应的字符串

4. String str = "Hello" ；右边直接用双引号

注意：直接写上双引号，就是字符串对象。

▶ 字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。

双引号直接写的字符串在常量池当中，new的不在池当中。

--- 对于基本类型来说，==是进行数值的比较

--- 对于引用类型来说，==是进行【地址值】的比较

▶ == 是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

（1）public boolean equals (Object obj) ：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true，否则返回false

注意：

a. 任何对象都能够用Object进行接收

b. equals 方法具有对称性，也就是a.equals(b) 和 b.equals(a)效果一样

c. 如果比较双方一个是常量一个是变量，推荐把常量字符串写在前面。

推荐：“abc”.equals(str) 不推荐：str.equals("abc)

（2） public boolean equalsIgnoreCase(String str) ：忽略大小写，进行内容比较

▶ String中与获取相关的常用方法有：

public int length() ：获取字符串当中含有的字符的个数，拿到字符串长度

public String concat(String str) ：将当前字符串和参数字符串拼接成为返回值新的字符串

public char charAt(int index)：获取指定索引位置的单个字符（索引从0开始）

public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值

▶ 字符串的截取方法：

public String substring(int index) ：截取从参数位置一直到字符串末尾，返回新字符串

public String substring(int begin ,int end) ：截取从begin开始，一直到end结束，中间的字符串

备注：[ begin , end ) 包含左边，不包含右边

▶ 下面这种写法，字符串中的内容仍然是没有改变的，上面有两个字符串 “ Hello ” 和 “ Java ”。strA当中保存的是地址值，本来地址值是Hello的0x666 ，后来地址值是Java的0x999 。

▶ String 当中与转换相关的常用方法有：

public char [ ] toCharArray() ：将当前字符串拆分成为字符数组作为返回值

public byte [ ] getBytes() ：获得当前字符串底层的字节数组

public String replace(CharSequence oldString , CharSequence newString) ：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串

备注：CharSequence意思是说可以接受字符串类型。

▶ 字符串的分割方法：

public String[ ] split(String regex) ：按照参数的规则，将字符串切分成为若干份

注意：split方法的参数其实是一个“正则表达式” ，今后学习。现在如果按照英文句点 “ . ” 进行切分，必须写 “ \\ . ”(两个反斜杠)

静态Static类

▶ 一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。

如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

【无论是成员变量，还是成员方法，如果有了static，都推荐使用类名称进行调用。

静态变量：类名称 . 静态变量

静态方法：类名称 . 静态方法() ; 】

【对于本类当中的静态方法，可以省略类名称。】

对于静态方法来说，可以通过对象名进行调用（正确，但是不推荐），也可以直接通过类名称来调用（正确，推荐）

▶ 注意：

1. 静态只能直接访问静态，不能直接访问非静态

原因：因为在内存当中是先有静态内容，后有的非静态内容。

【“先人不知道后人，但是后人知道先人”】

2. 静态方法当中不能用this关键字

原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

▶ 静态代码块

什么是静态代码块？定义在成员位置，使用 static 修饰的代码块 { }

位置：类中方法外

执行：随着类的加载而执行，并且只执行一次，优先于main方法和构造方法的执行

格式： public class Studen{

static {

// 执行语句

}

作用：给类变量进行初始化赋值

【说明：static 关键字可以修饰变量、方法、代码块。在使用的过程中目的还是想在不创建对象的情况下去调用方法。】

Arrays类(数组类)

java.util.Arrays是一个和数组相关的工具类，里面提供了大量的静态方法，用来实现数组的常见操作。

▶ public static String toString(数组) ：将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3...] ）

public static void main(String[] args){

            int arr = { 2,45,56,7,8,90} ;

            System.out.println(arr) ; // 打印数组，传递的参数是数组名，输出的是地址

            String s = Arrays.toString(arr) ; // 将数组内容转化为字符串

            // 静态方法在同一个类中可以直接通过方法名调用，不同类之间可以通过“ 类名称.方法名 ”调用

            System.out.println(s) ; // [2,45,56,7,8,90]

}

▶ public static void sort(数组) ：按照升序默认升序（从小到大）对数组的元素进行排序

注意：

1. 如果是数值，sort默认按照升序从小到大

2. 如果是字符串，sort默认按照字母升序

3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持（后面会学习）