四个原生类--Java语言（jdk自带的工具类）*

*Xiu *

已于 2023-03-06 07:32:39 修改

阅读量237

点赞数 1

分类专栏： AP CS java 文章标签： java 开发语言

于 2023-03-01 23:04:12 首次发布

本文链接：https://blog.csdn.net/weixin_45599930/article/details/128244860

版权

java 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

AP CS

3 篇文章 1 订阅

订阅专栏

The Math class

Math.random()

static double random（），返回值是0~1，一个小数，0可以取到，1取不到，最大值是0.99999....

class Test{
	public static void main(String args[]){
		System.out.println(Math.random());
	}
}

如果对其进行强制类型转换：结果只能取到0，一直为0；

System.out.println((int)(Math.random()));

所以需要乘一个10，可以得到0-9的整数，这10个数字，

如果要获得1-10的随机数，就+1，即可。

System.out.println(1+(int)(10*Math.random()));

static double abs(double x) 绝对值

static int abs(int abs)

static double sqrt(double x) 开根号，算出x的平方根，注意x必须为正数

static double pow(double base,double exponent)

pow(2,10) 代表 2的10次方。

The String class

String target ="abc";
String target2=new String("abc");
System.out.println(target.equals(target2));

int length()---字符串的长度

class Test{
	public static void main(String args[]){
		String target="abcde";
		System.out.println(target.length());
	}
}

substring()

String substring(int from ,int to)-------意思是从哪里开始到哪里结束。截出来一串字符串，from 是从哪里开始（包括）， to是从哪里结束（不包含）

class Test{
	public static void main(String args[]){
		String target="abcdefg";
		System.out.println(target.substring(2,6));
		System.out.println(target);
	}
}

substing 将返回值截取某一段出来，但是不会改变字符串的值。

2.String substring(int from) -----意思是从from开始到末尾结束，仍然不改变字符串的大小。

int indexOf(String str) 在当前字符串里面，str首次出现的位置

class Test{
	public static void main(String args[]){
		String target="abcdefgcdcd";
		//将会返回cd首次出现的位置
		System.out.println(target.indexOf("cd"));
	
	}
}

两种用法，找到参数里的字符串，他在原有字符串中首次出现的位置。但如果没有的话就会显示-1

（注意：这里面的h用的是单引号，单引号用于单个字符，双引号也不会报错）

class Test{
	public static void main(String args[]){
		String target="abcdefg";
		System.out.println(target.indexOf('h'));	
	}
}

int compareTo(String other)

相当于是做减号，当字符串长度相同时，比较字符串中字母的大小，对字母表中的排序进行排序的减法

字符串长度不同时，结果比较的是字符串长度的差值

Returns 0 if the value of this Integer is equal to the value of other, a negative integer if it is less than the value of other, and a positive integer if it is greater than the value of other.

class Test{
	public static void main(String args[]){
		//结果是-4，剪的是字符串的长度
		String target="cd";
		String target2="cdedhs";
		System.out.println(target.compareTo(target2));	
		//结果是1 ，减的是不同位开始字母的顺序
		String target="cdf";
		String target2="cdedhs";
		System.out.println(target.compareTo(target2));	
		//当两个字符串的位数和内容完全相同时，结果会是0
	}
}

char charAt(int Pos)

用来显示字符串中相应位置的字符

但如果没有这个位置的字符，会报错，字符串越界异常，结果产生的错误是在运行的时候产生的，而不是在编译的时候产生的，叫做异常Exception

equals 和 == 的区别，equals 测试String的内容，然而 == 会比较String作为本类创建的对象不同引用

The Array （1 dimension and 2 demension）

An ordered sequence of something makes an array.

conception：相同类型元素的有序集合

分类：静态数组Array、和动态数组

静态数组Array：数组的长度（元素的个数）不可以改变；动态则表示数组的长度可以改变。

静态数组的声明

type[] Name = new Type[n]; //表示静态数组的长度

type[]：表示数组的类型，【】表示生成的数组是一维的（这个静态数组的元素是一行，所有的元素是在同一行写完的）

Name：数组的名字

new：调用构造函数（熟悉）

Type[n] :静态数组的构造函数，n表示的是静态数组的长度，即表示可以放入多少个元素。

例： int[] scores={6,6,6,6,6}; 定义了一个名为scores 类型为整数的数组，有5个元素，每个元素的值为6，

怎么获得数组的长度呢？

final int attribute of length 属性，例如 name.length; scores.length 之类

数组除了定义基本数据类型还有引用数据类型

Human[] group ={new Human("Josh"),new Human("Andy")};

指的是 group 这个数组里面有两个元素，长度为2 ；用new 关键字调用Human这个类的构造函数生成Human类的对象，一个名为Josh 一个名为Andy

对于静态数组来说，计数的时候，首个元素和字符串是一样的，是从0开始而不是从1开始，

int i = scores[0]; //表示scores数组里面的第一个元素的这个基本数据类型的值 
Human a = group[1]; // 引用数据类型group里面的Andy这个引用，注意是引用不是对象

二维静态数组

比如生成一个2行3列的数组

int rowNumber =2;
int columnNumber =3;
double[][] a= new double[rowNumber][columNumber];

对于二维数组来说

a.length返回行数（number of rows）;

a[0].length 返回列的数目（number of column），这种一维的表示方法指的是第一行里面有多少个元素，就代表2维静态数组有多少列。如果一共就2行，写了个a[5].length 就会有风险，就会有异常，报错，所以写a[0]用来表示列数，一定不会出错。

练习

class Test{
	public static void main(String args[]){
		int[][] numbers=new int[10][10];
		for(int i=0;i<10;i++){
			for(int j=0;j<10;j++){
            //把当前数组中第i行第j列，进行赋值
            //第一行都是1，第二行都是2，第三行都是数字3
				numbers[i][j]=i+1;
				
			}
		}
		//当对一个不知道几行几列的数组进行操作时，需要用numbers.length获得行数，numbers[0].length获得列数
		for(int i=0;i<numbers.length;i++){
			for(int j=0;j<numbers[0].length;j++){
				//打印当前元素的值
				System.out.print(numbers[i][j]+" ");
			}
			System.out.println();
		}
}
	
}

静态数组的长度不能改变，可以把数组里的某一个值无论是基本还是引用，可以进行改变，

The ArrayList implements from list

动态数组list ，这个接口interface类里面，定义了，一个动态数组所具备的全部行为，数组中的元素和长度是可以改变的

动态数组里的元素的长度和个数是可以改变的，可以增加或者减少里面的元素

只有ArrayList类里面才有能够改变数组元素的个数的方法、

实现list接口的类是ArrayList ，

list 是一个接口，有很多类可以实现，其中一种叫做ArrayList，而Array指的是静态数组，是指的用一个Array 来实现一个list，用一个静态数组，来实现一个动态数组。

用法：

ArrayList<Double> samples = new ArrayList<Double>();

注意D是大写的，

ArrayList 里面只可以放引用数据类型，不能放primitive type ，

两个尖括号里的数据类型要保持一致；

动态数组中的（）里面是不用填写数值的，因为数组的长度是可以发生改变的，放的多回自动长大，放的少也会自动缩小。

考试中需要掌握的方法有如下六个：

int size() 动态数组的长度，注意是一个方法，而不是属性，

boolean add(E obj) 往动态数组里加入元素，注意是加到最后一位，add（）的返回值是boolean类型的，且永远会是true。

void add(int index ,E obj) 两个参数，表示可以把这个元素放在中间的位置，index是几，就表示要把它放在动态数组的第几位，后面的元的index会以此往后顺延，注意没有返回值。

E get(int index) ,get方法用来获得当前数组某一位上的元素值，比如这个动态数组中有三个元素 0，1，2，进行get（3），但是数组里没有第4个元素，这时计算机就会报错。返回值就是元素的引用，

E set(int index) , set动态数组的值不发生改变，而是设置的意思，add会增加数组的长度，但是set 不会，set会让动态数组的长度不变，只是让某一位的值替换为其他位的值，set也会有返回值，会将被替换的旧的那一位进行返回。

E remove（int index），删除，删除的谁，就会把谁的引用返回。

在一个静态或者动态数组里面，能否存储不同的数据类型？

Different data types elements in Array or List

import java.util.Arraylist

class Test{
		public static void main(String args[]){
			int[] a={34,56,78,91,11,22};
			//list 是接口类，ArrayList来实现这个接口类
			//子类对象可以给这个父类的引用
			//好处在于，后面的对象可以更加灵活，list实现的对象有很多，不止这一个
			List<String> article=new ArrayList<String>();
			//可不可以在这个数组里面放不同类型的数据呢?
			
			//不同类型的数据元素要求具有相同的父类
			List<Human> s = new ArrayList<Human>();
			//既可以添加学生类的对象，也可以添加老师类的对象，
			//以及人类的对象，从这个角度而言，确实可以将不同类别的元素放进去，
			
			//所以这个不同类型的元素呢，要么是父类本身要么是父类的子类。
			s.add(xxx)
		}


}

Wrapper class

将一个基本数据类型，赋予成一个对象的概念，尤其是在动态数组List当中，只能存放引用数据类型，也就是wrapper class

import java.util.Arraylist

class Test{
		public static void main(String args[]){
			int[] a={34,56,78,91,11,22};
			int b=10;
			//c 在这里相当于一个引用数据类型，c存放的是abc在内存中存放的地址
			String c="abc";
			
			//int 对应的引用数据类型叫做Integer
			//这将会在内存中，有一块区域，不仅存放了10，还存放Integer这个类里面相应的很多method，属性
			Integer B=10;
			Integer B=new Integer(10);//标准写法
			//对应的wrapper class
			int Integer
			boolean Boolean 
			double Double 
			char Character
			
			//放在数组当中，就必须要使用这些包装类
			List<Integer>
		}


}

Traverse 遍历 an array or list

import java.util.Arraylist

class Test{
		public static void main(String args[]){
			int[] a={34,56,78,91,11,22};//Array
			Integer[] a//没有问题
			List<int>//动态数组这样写就不对
			List<Integer>//ArrayList
		}
}

import java.util.Arraylist

class Test{
		public static void main(String args[]){
			int[] a={34,56,78,91,11,22，33};//Array
			//数组的遍历，将数组里的每一个值进行遍历
			//既然遍历那么必然会进行循环，从首位到最后一位
			
			//从第一个元素开始遍历，a.length数组的长度，
			for(int index=0;index<a.length;index++){
				System.out.println(a[index]);
			}
		}
}

for-each loop

import java.util.ArrayList;

class Test{
		public static void main(String args[]){
			int[] a={34,56,78,91,11,22,33};//Array
			
			for(int index=0; index<a.length; index++){
				System.out.println(a[index]);
			}
			System.out.println("it is the for each loop below:");
			//for each loop
//增强型的for循环，是通过一个冒号，把一个语句分割成两个部分，
//冒号的右侧是带循环的数组，可以是静态的也可是动态的，，
//冒号的左侧是target/数组里的每一个元素的代表，上面的index指的是位置
//a表示要循环的数组，
            //记得声明target这个变量 的类型，和数组的元素类型保持一致
			for(int target :a){
                //打印数组里的每一位
				System.out.println(target);
			}
	
		}
		
		
}

增强型的for循环可以自动的从第一位遍历到最后一位，但是也有缺点：

1.万一不是要循环遍历每一个元素，而是取中间的一小节，那么就不可以使用for each loop

2.没有元素的具体位置，只能得到值，如果想改变某个具体位置的值，是遍历不到的

import java.util.ArrayList;

class Test{
		public static void main(String args[]){
			int[] a={34,56,78,91,11,22,33};//Array
			
			for(int index=0; index<a.length; index++){
				System.out.println(a[index]);
				//把计数位的值，增大一倍
				if(index%2==1){
					a[index]*=2;
				}
			}
			System.out.println("it is the for each loop below:");
			//for each loop
			for(int target :a){
				System.out.println(target);
			}
	
		}
		
		
}