Java中的数据类型和操作符-编程知识

Java的数据类型：

>>>

数组另外一种传参形式：

输入：

switch:

快捷键：

快捷创建包：

提交Gitee仓库：

next和nextLine区别：

注意事项：

循环终止：

产生随机数：

比较字符串：

关闭方法：

数组的定义和初始化：

求数组长度：

数组的赋值：

打印数组：

引用变量赋值：

定义boolean类型数组：

增强for循环：

内存占据：编辑

引用对象的改变：

数组传参：

数组转换为字符串：

包里面的二分查找法：

用包中的方法对数组赋值：

数组的拷贝：

Arrays.copyOf:

Arrays.copyOfRange:

二维数组：

二维数组的定义：

二维数组的遍历：

二维数组转换为字符串：

二维数组赋值：

Java的数据类型：

和C语言比较像，分为基础类型和引用类型（类似于指针）。基础类型分为8大类，引用类型我们这里先知道String。

因为Java的int无论在那个机器上都是4个字节，就增强了可移植性。为了方便，没有像C语言一样分为long和long long类型，只有一个long类型，占据8个字节。

IDEA编译器会识别很多错误，但是有些是难以发现的，类似于Bug。

为了区分int和long类型，一般建议long类型变量的初始值后加L（大写易区分）。

long a = 10L;

和C语言一样，整数计算时出现小数，需要在其中以数字上加上.0。

和C语言小数类型的存储一样，小数没有一个非常精准的数字。

double、float类型也遵循IEEE 754标准（详情请看数据的存储（类型的提升）-CSDN博客）。因为Java区分比较明确，所以写float时数据后面一定要加上f，默认小数为double类型。

但是byte b = 10，就不需要进行标识，这是因为，对于byte short小于4字节的类型赋值时，没有超过表示的最大范围的时候，不会被解析为整形。所以对于高字节数据赋给低字节数据，需要强制类型转换。

要是有关联的数据类型，像boolean类型就不能强制转换成其他类型。

此时我们观察一下代码：

byte f1 = 10;
byte f2 = 20;byte f3 = f1 + f2;//此时会进行整形提升，转换为4字节

所以我们要使用int类型接受：

byte f1 = 10;
byte f2 = 20;//byte f3 = f1 + f2;//此时会进行整形提升，转换为4字节
int f3 = f1 + f2;

计算机中的字符本质上是一个整数，在C语言中使用ASCII表示字符，而Java中使用Unicode表示字符，因此一个字符占用两个字节，可以表示中文。

java中不存在Boolean和int的相互转换，不存在1表示true，0表示false的用法。Java虚拟机规范中，没有明确规定boolean占几个字节，也没有专门来处理boolean的字节码指令，在Oracle中，占一个字节。

将高字节数据赋给低字节数据，需要强制类型转换。

转换类型必须是要是有关联的数据类型，像boolean类型就不能强制转换成其他类型。

java中字符串类型，不是以\0结尾，它不以任何东西结尾，例：String str = “hello”就是以o进行结尾的。在底层存储的就是数组。

字符串的拼接：

这里有一个短路逻辑，就是如果在遇到字符串之前都是正常运算，遇到字符串之后都是打印，就是+预算符都变成了连接运算符。

我们来看取模规则（直接上截图）：

对于小数取模，结果为小数。

System.out.println(11.5%2);

对于分母作为0，则会抛出异常（算数异常）。

两种不同类型运算最好进行强制转换：

这里不支持计算完以后得到真假之后继续计算：

直接报错，但是C可以运行，因为boolean的值不能比较。

!

非只能用于boolean类型。

>>>

我们知道右移的话会根据最高位符号位去补其他空白位，所以Java中就有了无符号右移，无视最高位符号位，最高位补0。但是没有无符号左移这个运算符。

?:

我们来观察三目操作符。

public static void main(String[] args) {boolean flag1 = true == true ? false ? true : false : true;boolean flag2 = flag1;System.out.println(flag2);
}

数组另外一种传参形式：

Java中数组还有另外一种传参方式。

public class Again {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5};System.out.println(add(arr));}/*public static int add(int[] arr) {int x = 0;for (int y : arr) {x += y;}return x;}*///另外一种方式 ...叫做可变参数public static int add(int... arr) {int x = 0;for (int y : arr) {x += y;}return x;}
}

所以这只是换了一种形式，int...叫做可变参数。

输入：

Java的输入要利用另外的scanner。

Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();

switch:

switch只允许三种，整形（int），字符型（char）和字符串（String）（byte、char 和 short类型可以安全转换为int，所以switch（key）的key类型可以为byte、char和short。long和double等类型是不能安全的转换为int，所以key的类型不能为long和double）。

快捷键：

当我们使用for循环时，可以直接fori，这样可以快速生成for循环。

当我们想想打印一个值却没有写printf函数，就可以在后面加上.sout来直接生成。

所以我们在.的时候，提示如果没有想要的语句那么编译会出错。

快捷创建包：

当我们要创建包时，也可以使用快捷方式使用类创建包。

提交Gitee仓库：

IDEA可以提交Gitee数据。

next和nextLine区别：

public class Hello_Java {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入你的姓名：");String name = scanner.nextLine();System.out.println(name);}
}

next遇到空格就结束；nextLine会读一整行。

注意事项：

public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("输入年龄：");int age = scanner.nextInt();System.out.println(age);System.out.println("输入姓名：");String name = scanner.nextLine();System.out.println(name);System.out.println("输入工资：");int salary = scanner.nextInt();System.out.println(salary);
}

此时录入name时，因为会有一个回车，就把name赋值为回车了，所以我们要多写一个scanner.nextLine()来把回车消化掉，和C一样。

public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("输入年龄：");int age = scanner.nextInt();System.out.println(age);scanner.nextLine();System.out.println("输入姓名：");String name = scanner.nextLine();System.out.println(name);System.out.println("输入工资：");int salary = scanner.nextInt();System.out.println(salary);
}

循环终止：

是否还记得文件读到EOF终止，scanf读到EOF终止，我们要输入Ctrl + Z来终止输入，Java中我们使用Ctrl + D来终止。

产生随机数：

随机数是一个类，所以要产生一个对象。

public static void main(String[] args) {Random random = new Random();int randNum = random.nextInt(100);//[0-100)//不包含100Scanner scanner = new Scanner(System.in);while(true){System.out.println("请输入你要猜的数字：");int num = scanner.nextInt();if (num > randNum){System.out.println("猜大了");}else if(num < randNum){System.out.println("猜小了");}else{System.out.println("猜对了是"+randNum);break;}}
}

和C语言一样，其实也需要设置种子，但是默认就是时间戳。

比较字符串：

和C语言一样，不能之间比较字符串，需要用到方法（函数）。比较字符串在java中，使用.equals方法。

关闭方法：

记得要关闭方法，这叫做关闭资源。

public static void main(String[] args) {Scanner scanner = new Scanner(System.in);scanner.close();
}

数组的定义和初始化：

int[] array = {1,2,3,4};

和C语言不一样，其实也能和C语言一样定义，但是不建议。因为int[]也是类，所以还有另一种定义方法。

int[] array = {1,2,3,4};
//两者等价
int[] arr2 = new int[]{1,2,3,4};

关键字，一般用来new对象。数组就是一个对象。

所以我们可以给它定义长度：

int[] arr3 = new int[10];

此时数组没有初始化，默认会将数组将数组初始化为0。

Java中也是根据下标访问数组元素的。下标数组越界会报异常。

求数组长度：

因为数组是一个对象，所以有对应的方法.length来求数组的长度。

Java中支持数组个数不是常数，但是还是固定大小。

int n = 10;
int[] arr2 = new int[n];

数组的赋值：

数组的赋值只有一次机会，否则就需要通过下标来修改。

打印数组：

其实和C语言一样，就是记录首地址，但是Java中没有指针，所以数组名不是指针，我们将其称为引用变量。

引用变量赋值：

因为引用变量可以理解为指针，因为Java中必须将局部变量初始化，当我们使用数组不知道赋值什么时，可以赋值为空，null这里必须是小写。

如果此时我们直接调用length方法则会报空指针异常。

null在Java中表示“空引用”，也就是不指向任何对象的引用。因为在C语言中，NULL代表指向0号地址，此地址为保留地址，不能访问。但Java中null和0号地址没有任何关联。

定义boolean类型数组：

如果定义的是一个boolean类型的数组，默认初始化为false。

增强for循环：

在java中，有一个叫做增强for循环的东西，比如for（int x : arry）遍历这个数组的时候，把数组中的元素赋值给x。

int[] array = {1,2,3,4};for (int i = 0; i < array.length; i++) {System.out.print(array[i] + " ");
}
System.out.println();//增强for循环  for-each
for (int x : array){System.out.print(x + " ");
}

区别在于for循环遍历时，可以拿到下标；for-each拿不到下标，所以只能遍历，不能对某一个下标进行操作。

内存占据：

我们平时就使用Java虚拟栈和堆的空间。

引用对象的改变：

比如此时我们定义一个数组：

描述为 arr 这个引用指向了一个数组对象。所以 arr 可以当做引用变量，但它并不直接存处对象本身，可以简单理解存储的是对象在堆中空间的起始地址。通过改地址，引用变量便可以去操作对象。

所以数组名改变就相当于指针指向改变。我们来看下图：

注意以上代码只能在Java中运行并不报错，但是C语言会报错.

所以以后再在Java中看到：

int[] arr1 = {1,2,3,4};
int[] arr2 = arr1;

就相当于 arr2 这个引用指向了 arr1 这个引用所指向的对象。

对象不能指向对象，只有引用才能只想对象。

在Java中，因为类里面包含方法，所以方法可以是乱序的，不用非得定义在main方法的上面。

数组传参：

其实和C语言一样。

public static void main(String[] args) {int[] arr = {1, 2, 3, 4};func1(arr);for (int x : arr){System.out.print(x + " ");}System.out.println();}public static void func1(int[] arr){arr[0] = 99;
}

注意，如果里面新建了，不会影响外面的值。

public static void main(String[] args) {int[] arr = {1, 2, 3, 4};func2(arr);for (int x : arr){System.out.print(x + " ");}
}
public static void func2(int[] arr){arr = new int[]{11,22,33,44,55};
}

所以也可以用方法返回数组。

public static void main(String[] args) {int[] ret = func3();for (int x : ret){System.out.println(x);}
}public static int[] func3(){int[] ret = new int[2];ret[0] = 99;ret[1] = 199;return ret;
}

数组转换为字符串：

在Java中，有一种工具类，比如关于数组的工具类Arrays。我们可以点击Ctrl查看其所有方法。此时我们将数组转换为字符串打印。

public static void main(String[] args) {int[] arr = {1,2,3,4,5};String s = Arrays.toString(arr);System.out.println(s);}

我们也可以通过自己实现Arrays.toString方法。我们要考虑全面问题，所有情况都要考虑在内。

public static void main(String[] args) {int[] arr = {1,2,3,4,5};//String s = Arrays.toString(arr);System.out.println(MyToSting(arr));}
public static String MyToSting(int[] arr){if (arr == null){//为空return "null";}if (arr.length == 0){//没有元素return "[]";}String ret = "[";for (int i = 0; i < arr.length; i++){//拼接ret += arr[i];if (i != arr.length - 1){ret += " ,";}}ret += "]";return ret;
}

java中提供了各种包，就比如我们刚才使用Arrays.toString需要导入java.util.Arrays包，这里面包含了一些操作数组的常用方法。

包里面的二分查找法：

在java包中有二分查找法（前提数组已经有序），如果没有找到，会返回一个负数，这个负数的计算可以看源码。

public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5, 6};//Arrays.binarySearch是二分查找System.out.println(Arrays.binarySearch(arr, 10));//返回的是下标//没有找到会返回负数（具体细节看源码）
}

用包中的方法对数组赋值：

Java中可以用包对数组进行赋值。

public static void main(String[] args) {int[] arr1 = new int[10];int[] arr2 = new int[10];Arrays.fill(arr1,9);//整体赋值System.out.println(Arrays.toString(arr1));Arrays.fill(arr2,0,6,9);//区间赋值//[)左闭右开System.out.println(Arrays.toString(arr2));
}

数组的拷贝：

Arrays.copyOf:

我们使用Arrays包中的.copyOf的方法，具体可以看源码。

public static void main(String[] args) {int[] arr1 = {2,4,5,3};int[] arr2 = new int[arr1.length];//实现数组的拷贝int[] copy = Arrays.copyOf(arr1, arr1.length);//返回的是数组System.out.println(Arrays.toString(copy));
}

当我们传入的长度参数过大时，可以完成扩容效果，不过扩容的内容会初始化为0。

Arrays.copyOfRange:

这个方法可以指定范围，它是拷贝区间。

public static void main(String[] args) {int[] arr = {1,2,3,5};int[] copy = Arrays.copyOfRange(arr,0,3);System.out.println(Arrays.toString(copy));}

我们进入内部看源码。

所以它和Arrays.copyOf是有区别的，我们使用时应当注意。底层代码是由C/C++实现的，所以我们无法在往下查看。

二维数组：

二维数组的定义：

其实和C语言一样，但是Java中的二维数组可以使不规则的。

int[][] arr1 = {{1,2,3}, {4,5,6}};
int[][] arr2 = new int[][]{{1,2,3}, {4,5,6}};
int[][] arr3 = new int[2][3];

Java中可以省略列，不能省略行，因为其可以不规则。

int[][] arr5 = new int[2][];
//可以省略列，这是不规则二维数组

二维数组的遍历：

那么我们如何遍历数组呢？第一个想到的就是看行看列各是多少个，之后遍历。

public static void main(String[] args) {int[][] arr1 = {{1,2,3}, {4,5,6}};System.out.println(arr1[0][1]);//遍历打印for (int i = 0; i < 2; i++) {for (int j = 0; j < 3; j++) {System.out.print(arr1[i][j] + " ");}System.out.println();}
}

在Java中，其实很快能够遍历打印，因为是引用变量，所以分别指向两个地址。

int[][] arr1 = {{1,2,3}, {4,5,6}};
for (int i = 0; i < arr1.length; i++) {for (int j = 0; j < arr1[i].length; j++) {System.out.print(arr1[i][j] + " ");}System.out.println();
}

二维数组转换为字符串：

此时我们将其转换为字符串打印，此时需要用到Arrays.deepToString。

System.out.println(Arrays.deepToString(arr1));

我们也可以利用增强for循环打印。

//利用增强for循环打印
for(int[] tmp : arr1){for (int x : tmp){System.out.print(x + " ");}System.out.println();
}

如果数组中什么都没有，还是会报空指针异常。

二维数组赋值：

不规则二维数组没有初始化就打印，回报空指针异常。我们可以观察他们的值。

此时只能这样赋值。

int [][] arr1 = new int[2][];
//因为赋值只有一次机会，所以不能这样
//arr1[0] = {1,3,5};
arr1[0] = new int[]{1,3,5};
arr1[1] = new int[]{1,2,3,4,5};

这就叫做不规则的二维数组。