笔记：JAVA基础摘要

数据类型

整型

类型	存储要求	取值范围
int	4	-2147483648~2147483647
short	2	-32768~32767
long	8	-9E18~9E18
byte	1	-128~127

• long有后缀L或l
• JAVA中没有无符号整型

浮点型

类型	存储要求	取值范围
float	4	有效位数6~7位
double	8	有效位数15位

• NaN表示出错（不是一个数字）计算0/0或者是负数的平方根结果为NaN；
• 常量Double.POSITIVE_INFINITY、Double.NEGATIVE_INFINITY、Double.NaN分别表示正溢出、负溢出和出错
  例如 ：if（Double.isNaN(x)）//判断x是否不是一个数字

变量

变量初始化

• JAVA严格区分大小写
• 逐一声明变量可以提高程序的可读性
• 声明一个变量后必须用赋值语句对变量进行显式初始化
  int a;
  a=12;
  or
  int a=12;

常量

• 利用关键字 final 指示常量，例如：
  final double CM_PER_INCH = 2.54;
• 类常量，定义于main方法的外部可以在一个类中的多个方法中使用，若被声明为public，其他类中的方法也可以引用这个常量

运算符

Math类中常用的函数：

• 计算数值平方根,例如：double x=Math.sqrt(4);
• 幂运算，例如：double y=pow(x,a); //y=xa，x、a都是double类型，返回的值也是double类型；
• floorMod方法目的解决整数取余n/a中当操作数n为负数的问题（例如：对于n/2，当n为负数时，n/2为-1）
  floorMod(x,n); //x%n，总会得到一个1~(n-1)之间的数
• 两个分别表示近似 п 、e 常量的值: Math.PI、Math.E
• import static java.lang.Math.*;

数值转换

特殊强制转换

• 使用Math.round方法对浮点数进行舍入操作，但是注意要将结果强制类型转换，因为round方法返回的是long类型，例如：
  double x=3.156;
  int y=**(int)**Math.round(x);
• 可以在使用中使用二元运算符，例如：
  x+=3 等价于 x=x+3
  但是如果运算符得到一个值的类型与左侧的操作数类型不同，就会强制转换为左侧操作数的类型，例如：
  x+=3.5 等价于 x=(int)(x+3.5)

枚举类型

有时候变量的取值在一个有限的取值中，为了防止变量保存的是一个错误的值，可以自定义一个枚举类型，例如：
enum Size{ SMALL,MEDIUM,LARGE,EXTER_LARGE };
Size s = Size.SMALL;

字符串

• Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义类String

• 字串：String类中substring方法可以从一个较大的字符串中取出一个字串，例如：
  String x = “Hello”;
  String y = x.substring(0,3); //y = “Hel”,y的长度为3-0

• 连接：Java语言允许用**+**将两个字符串进行连接，例如
  String x1 = “Hel”;
  String x2 = “lo”;
  String y = x1+x2; //y = “Hello”
  当字符串与非字符串进行连接时，后者转换为字符串
  int a = 13;
  String x1 = “hello”;
  String y = x1+a; //y = “hello13”
  System.out.println{"The answer is “+answer};
  如果想将多个字符串连接在一起并且用定界符”/“分开，可以使用 join方法：
  String all = String.join(” / ", “s”, “m”,“all”); //all = “s / m / all”

• 不可变字符串：String类没有提供可以修改字符串的方法，无法修改字符串中的字符，所以java中将String类对象称为不可变字符串。其主要目的是将各种字符串存放在公共的存储池中，使字符串白能量指向存储池中相对应的位置，如果复制一个字符串变量，则原始字符串和复制字符串共享相同的字符。
  例如：String x = “Hello”; //字符串"Hello"不可变，但是对于变量x，可以修改使其引用另一个字符串
  x=x.substring(0,3)+“pl!!!”; //x=“Helpl!!!”
  https://blog.csdn.net/qq_38101834/article/details/87310282

• 检验字符串是否相等使用equals方法：
  s.equals(t);
  “Hello”.equals(t);
  s==t; //判断的是两个字符串是否放置在享同位置
  “Hello”.equalsIgnoreCase(“hello”); //不区分大小写

• 空串""是长度为0的字符串
  检验：if(str!=null&&str.length()!=0)

• 构建字符串：有时候需要由较小的字符串构建字符串，而按照字符串连接来构建效率低，并且每次构建都会产生一个新的字符串对象，浪费空间。可以使用StringBuilder类来避免这个问题的发生，例如：

StringBuilder builder = new StringBuilder();
builder.append(ch);
builder.append(str);
String need = builder.toStrng(); //使用toString方法得到一个String对象 

输入输出

读取输入

1. 构造一个Scanner对象：Scanner in = new Scanner(System.in);

2. 使用Scanner类的方法实现输入操作：
   String x1=in.nextLine(); //输入一行包含这一行中可能有的空格
   String x2=in.next(); //读取一个单词，以空格作为分隔符
   int x3=in.nextInt(); //读取下一个整数
   double x4=in.nextDouble(); //读取下一个浮点数

3. 在程序开始添加import java.util.*;

import java.util.*;
public class InputTest {
public static void main(String[] args) {
  Scanner in=new Scanner(System.in);
  System.out.println("What is your name?");
  String name=in.nextLine();
  System.out.println("What is your age?");
  int age=in.nextInt();
  System.out.println("Hello "+name+", next year, your age will be "+(age+1));
 }
}

输出：

What is your name?
Aym
What is your age?
17
Hello Aym, next year, your age will be 18

4. Console类：解决了Scanner类不适合从控制台读取密码，达到在对密码进行处理后，马上用一个填充值覆盖密码的目的。

  Console con=System.console();
  String username=con.readLine("User name:");
  char[] passwords=con.readPassword("Passwords:");

格式化输出

• 使用printf方法，例如：
  `System.out.printf(“Hello %s , next year, your age will be %d”, name, (age+1));// printf转换符

  System.out.printf("%,.2f", 10000.0/3.0);// 3,333.33 用于printf的标志
  `
  
  

数组

import java.util.*;
public c/lass Array01 {
	public static void main(String[] args) {
  int[] a=new int[10];//声明变量a并使用new将变量a初始化为一个真正的数组
  for(int/ i=0;i<a.length;i++) {
   a[i]=i+1;
  }
//输出方式：
  for(int element:a) {
   System.out.println(element);
  }//正常输出
  System.out.println(Arrays.toString(a));
  //输出[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，一个包含数组值的字符串
  
  int[] smallPrimes= {1,3,4,2,7};//创建对象并同时赋值，无需用new初始化
  smallPrimes=new int[] {12,34,2,12,3};//使用了匿名数组，等价于下述，可以在不创建新变量的情况下重新初始化一个数组
  //int[] anonymous= {12,34,2,12,3};
  //smallPrimes=anonymous;
  
  //数组拷贝，两个变量将引用同一个数组
  int[] copySmallPrimes=smallPrimes;
  copySmallPrimes[3]=33;
  System.out.println(Arrays.toString(smallPrimes));//输出[12, 34, 2, 33, 3]
 }

例题：一种抽彩游戏，输入待抽取的数字个数和最大值，得到从小到大排列的随机数。

import java.util.*;
import java.util.*;
public class LotteryDrawing {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		System.out.println("How many numbers do you need?");
 		 int k=in.nextInt();
  		System.out.println("What is the highest number you can draw?");
  		int n=in.nextInt();
  		//给可供选择的数赋值
  		int[] number=new int[n];
  		for(int i=0;i<number.length;i++) {
   		number[i]=i+1;
  		}
  		//选出随机数
  		int[] result=new int[k];
  		for(int i=0;i<result.length;i++) {
  			 int r=(int)(Math.random()*n);//random返回一个从大于0小于1的值
   			result[i]=number[r];
   			//由于最后一个值在这一轮不可能被抽到，所以将它与被抽到的值交换,避免重复抽取
   			number[r]=number[n-1];
   			n=n-1;
   		}
   		Arrays.sort(result);//对数值型数组排序
  		System.out.println("Bet as the following combination.It will make you rich!");
  		for(int r:result) {
  		 System.out.println(r);
 		 }
 	}
 }

输出结果：

How many numbers do you need?
7
What is the highest number you can draw?
78
Bet as the following combination.It will make you rich!
5
7
15
23
27
70
73