java的常用引用类、数组、String类

最新推荐文章于 2021-11-15 19:31:47 发布

Quinto0

最新推荐文章于 2021-11-15 19:31:47 发布

阅读量221

点赞数 1

分类专栏： java基础语法文章标签： java语法基础 java数组 java常用类并预言

本文链接：https://blog.csdn.net/weixin_43786255/article/details/90554372

版权

java基础语法专栏收录该内容

14 篇文章 1 订阅

订阅专栏

java的常用引用类、数组、String类

1. 常用引用类

1.1 Scanner

一个简单的文本扫描器类。

使用：

//创建扫描器对象

Scanner sc = new Scanner(System.in);

//接收用户输入字符串类型的数据

String str = sc.next();

//接收用户输入整数类型的数据

int num = sc.nextInt();

//接收用户输入小数类型的数据

double d = sc.nextDouble();

Scanner sc = new Scanner(System.in);
System.out.print("请输入姓名：");
//输入姓名
String name = sc.next();		
//输入年龄 
System.out.println("请输入年龄 :");
int age = sc.nextInt();
//输入工资 
System.out.print("请输入工资：");
double salary = sc.nextDouble();
//输出
System.out.println("姓名："+name+"，年龄："+age+",工资:"+salary);

1.2 Random

该类的实例用于生成伪随机数的流。

使用：

//创建Random对象

Random rand = new Random();

//0~9 任意一个整数 [0,10)

int n = rand.nextInt(10);

//0.0-1.0任意一个double数[0.0,1.0)

double d =rand.nextDouble();

Random rand = new Random();
//生成0~9 任意一个
int n = rand.nextInt(10); 
//生成0.0~1.0 任意一个double数
double d =rand.nextDouble(); 
System.out.println(n);
System.out.println(d);

1.3 Math

Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

常用值与函数：

函数	描述
Math.random	返回0，1之间的一个随机数
Math.max	求两数中最大
Math.min	求两数中最小
Math.sqrt	求开方
Math.ceil	得到不小于某数的最大整数
Math.floor	得到不大于某数的最大整数
Math.rint	求距离某数最近的整数（可能比某数大，也可能比它小）
Math.round	同上，返回int型或者long型（上一个函数返回double型）
Math.exp	求e的任意次方
Math.log10	以10为底的对数
Math.log	自然对数
Math.pow	求某数的任意次方, 抛出ArithmeticException处理溢出异常
Math.PI	记录的圆周率
Math.E	记录e的常量
Math.abs	求绝对值
Math.sin	正弦函数
Math.asin	反正弦函数
Math.cos	余弦函数
Math.tan	正切函数
Math.toDegrees	弧度转化为角度
Math.toRadians	角度转化为弧度
Math.IEEEremainder	求余

使用： //double类型的数据，[0.0,1.0)

Math.random();

double d = Math.random();   
//生成0-1的整数
double random = Math.random();
System.out.println(random);
//生成1-10的整数
int n = (int)(Math.random()*10)+1;
System.out.println(n);

2.0 数组

数组概念:可以存储一组相同类型的数据。

2.1 一维数组

语法：（1）类型[] 数组名;

（2）类型数组名[];

静态初始化：（1）类型[] 数组名 = new 类型[]{值1,值2，…}；

（2）类型[] 数组名；

数组名 = {值1,值2，…}；

动态初始化：类型[] 数组名 = new 类型[长度];

必须要添加长度,一旦分配长度，该数组的空间是不可改变的；赋值：可以通过下标给数组赋值；元素的个数:length可以获取数组中元素的个数

注意事项：（1）数组中下标是从0开始

（2）空指针异常：java.lang.NullPointerException

（3）索引越界异常：java.lang.ArrayIndexOutOfBoundsException

数组的操作：（1）求最大值

int array[] = new int[] {11,55,22,99,88}; 
//最大值 
int max = array[0];
//遍历数组
for(int i=1;i<array.length;i++) {
	if(max<array[i]) {
		max=array[i];
	}
}
System.out.println("最大值 ："+max);

（2）最小值

int array[] = new int[] {11,55,22,99,88}; 
//最小值 
int min = array[0];
//遍历数组
for(int i=1;i<array.length;i++) {
	if(min > array[i]) {
		min = array[i];
	}
}
System.out.println("最小值 ："+ min );

（3）求和

int array[] = new int[] {11,55,22,99,88}; 
//数组中的和 
int sum = 0;
//遍历数组
for(int i=0;i<array.length;i++) {
	sum += array[i];
}
System.out.println("数组的和 ："+ sum );

（4）平均值

int array[] = new int[] {11,55,22,99,88}; 
//数组中的和 
double sum = 0;
//遍历数组
for(int i=0;i<array.length;i++) {
	sum += array[i];
}
//平均值
double avg = sum/array.length;
System.out.println("数组的平均值 ："+ avg );

（5）复制

//旧数组
int[] array = new int[]{11.55.88.33.66.22}
//新数组
int[] newArray = new int[array.length];
//遍历旧数组
for(int i=0;i<array.length;i++) {
	newArray[i]=array [i];
}

（6）反转

int array[] = new int[] {11,55,22,99,88}; 
System.out.println("反转前：");
for(int i=0;i<array.length;i++) {
	System.out.print(array[i]+"  ");
}
//遍历数组
for(int i=0;i<array.length/2;i++) {
    //交换位置
	array[array.length -1 -i] = array[i]^array[array.length -1 -i];
    array[i] = array[array.length -1 -i]^array[i];
    array[array.length -1 -i] = array[array.length -1 -i]^array[i];
}
System.out.println("反转后：");
for(int i=0;i<array.length;i++) {
	System.out.print(array[i]+"  ");
}

（7）冒泡排序

int array[] = new int[] {11,55,22,99,88}; 
//遍历数组
for(int i=0;i<array.length -1;i++) {
    for(int j = 0;j < array.length - 1;j++) {
        if(array[j] > array[j+1]){
            array[j+1] = array[j+1]^array[j];
            array[j] = array[j+1]^array[j];
            array[j+1] = array[j+1]^array[j];
        }
    }
}
System.out.print("按从小到大顺序：" );
for(int i=0;i<array.length;i++) {
	System.out.print(array[i]+"  ");
}

（8）选择排序

int array[] = new int[] {11,55,22,99,88}; 
//遍历数组
for(int i=0;i<array.length -1;i++) {
    int z = i;
    for(int j = i+1;j < array.length;j++) {
        if(array[z] > array[j]){
            z = j;
        }
    }
    if(z != i) {
        array[z] = array[z]^array[i];
        array[i] = array[z]^array[i];
        array[i] = array[z]^array[i];
    }
}
System.out.print("按从小到大顺序：" );
for(int i=0;i<array.length;i++) {
	System.out.print(array[i]+"  ");
}

2.2 二维数组

语法：（1）类型[][] 数组名;

（2）类型数组名[][];

静态初始化：（1）类型[][] 数组名 = new 类型[][]{{值1,值2}，{值3,值4}…}；

（2）类型[][] 数组名；

数组名 = {{值1,值2}，{值3,值4}…}；

动态初始化：类型[][] 数组名 = new 类型[长度1][长度2];

注意：二维数组可以看作行或列，由于数组的下标起始值为 0，因此行和列的下标需要减 1。

二维数组的操作：（1）获取单个元素

int[][] array = {{1,2},{3,4,5},{6,7,8,9}};
//打印数组的行数
System.out.println(arr.length);
//打印数组第2行的拥有的元素即列数
System.out.println(arr[1]);
 //打印数组第1行第2列的元素 
System.out.println(arr[0][1]);

（2）获取整行元素

int[][] array = {{1,2},{3,4,5},{6,7,8,9}};
Scanner scan=new Scanner(System.in);
System.out.println("当前数组有"+array.length+"行，请输入您要查看的行数：");
int num =scan.nextInt();
for(int i=0;j<array[num-1].length;i++) {
    System.out.println("第"+num+"行的第["+i+"]个元素的值是："+array[num-1][i]);
}

（3）获取整列元素

int[][] array = {{1,2},{3,4,5},{6,7,8,9}};
Scanner scan=new Scanner(System.in);
System.out.println("请输入您要获取的列：");
int num=scan.nextInt();
for(int i=0;i<array.length;i++) {
   System.out.println("第 "+(i+1)+" 行的第["+num+"]个元素的值是"+array[i][num]);
}

（4）遍历

int[][] array = {{1,2},{3,4,5},{6,7,8,9}};
//遍历二维数组 
for(int i=0;i<arr.length;i++) {
	for(int j=0;j<arr[i].length;j++) {
		System.out.print(arr[i][j]+"  ");
	}
}

3 String

String类代表字符串, 字符串不变,它们的值在创建后不能被更改

StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。tringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

String s1 = "abc";		
s1+="bcd";  //重新开辟空间
//synchronized
StringBuffer buf  =new StringBuffer("abc");
buf.append("bcd");
//效率高
StringBuilder str = new StringBuilder("abc");
str.append("bcd");  //不会开辟新空间
System.out.println(s1);  //abcbcd
System.out.println(str.toString());
//StringBuilder>StringBuffer>String  效率高到底

字符串在内存中是以字符的方式存储的。

String str = "abc";相当于： char data[] = {'a', 'b', 'c'};String str = new String(data);

字符串的比较见如下代码：

public static void main(String[] args) {
	String s1 = "abc";
	String s2 = "abc";
	String s3 = new String("abc");
	//== 地址
	//equals比较字符串，比较每个字符
	System.out.println(s1==s2);   //true
	System.out.println(s1==s3);   //false
	System.out.println(s1.equals(s3));  //true
		
	String s4 ="ab"+"c"; //编译时确定
	String s5  ="ab"+ new String("c");  //运行时确定
	String s6 ="ab";
	String s7 = "c";
	String s8 =s6+s7;
	System.out.println("=======================");
	System.out.println("s4==s1:"+(s4==s1));  //true
	System.out.println("s5==s1:"+(s5==s1));  //false
	System.out.println("s8==s1:"+(s8==s1));  //false
	//
	String s9 = s8.intern();  //在常量池地址
	System.out.println("s9==s1:"+(s8.intern()==s1));   //true
	System.out.println(s8.equals(s5));  //true
}