C++快速上手java备战期末考——运算符，输入输出和数组

文章目录

上期回顾
运算符
- 一、逻辑运算符（最大区别之一）
- [二、移位运算符（Java 有独有运算符）](#二、移位运算符（Java 有独有运算符）)
- 算术运算符
- [关系运算符 ==](#关系运算符 ==)
- 其他细节区别
程序逻辑控制
Java输⼊输出⭐️⭐️⭐️
方法
- 与C语言的主要区别
数组
- 数组的创建
- 数组的遍历
- 数组是引用数据类型
- - 基础数据类型和引用数据类型的区别
- 操作数据⼯具类Arrays
- - 数组转字符串.toString
  - [数组拷⻉ .copyOf](#数组拷⻉ .copyOf)
  - 查找数组中指定元素(顺序查找).find
  - 查找数组中指定元素(⼆分查找).binarySearch
  - 数组排序(冒泡排序).sort
  - 数组逆序.reverse
- ⼆维数组
- - 不规则的⼆维数组
- 下期预告
- 结语

◆ 博主名称：此生决int

大家好，欢迎来到我的博客~

⭐ 个人专栏：快速复习系列

⭐ 热门专栏：算法基础到精通系列

上期回顾

上期我们主要介绍了

文章概要

这里是引用

运算符

90% 的基础运算符（+ - * / = == != > <）用法完全相同，但 逻辑、移位、类型运算、字符串、语法限制 是两者的核心区别，也是最容易踩坑的地方。

一、逻辑运算符（最大区别之一）

1，Java的逻辑语句只能是Boolean类型的语句！！！

2，Java里面的&和|是没有短路这一说法的&&和||

c 复制代码

// C 合法：整数可以直接当布尔值
if (10 && 0) { }

java 复制代码

// Java 报错：逻辑运算只能用 true/false
if (10 && 0) { }

2，Java里面的&和|在操作数是boolean时，也可以做逻辑运算，但是不存在短路现象

二、移位运算符（Java 有独有运算符）

多了一个无符号>>>右移，原本的>>当作有符号右移

1，<<左移（一样）

2，>>右移

C，

无符号类型：高位补0

有符号类型：高位补符号位

Java

高位补符号位

3，>>>无符号右移（Java独有）

高位补0；

算术运算符

Java：%不仅可以对整型取模，也可以对double类型取模

java 复制代码

System.out.println(11.5 % 2.0);
// 
运⾏结果
 
1.5

对于

c 复制代码

char a=1;
char b=2;
char c=a+b;

C语言会先将a，b提升为int进行计算，再自动赋值给char类型的c，不会报错

java 复制代码

char c = (char)(a + b);   // ✅ 显式强制转换

java 复制代码

char a=1;
char b=2;
char c=a+b;

对于Java，他也会提升为int，但要你自己强制类型转换为char，否则报错。

关系运算符 ==

C：可比较任意数值、指针，无严格类型检查

Java：

基本类型：比较值

引用类型：比较内存地址（要比较就用 equals() 比较内容）

禁止不同类型引用比较

java 复制代码

String s1 = new String("a");
String s2 = new String("a");
s1 == s2;   // Java ❌ false（地址不同）
s1.equals(s2); // ✅ true

其他细节区别

1，Java没有sizeof

2,java没有指针，所以，*（解引用），&（取地址）都没有。

3，成员访问

C：指针用 ->，普通变量用 .；

Java：统一用 .，无指针，无 ->。

程序逻辑控制

1，if里面必须是boolean类型表达式

2，swihch（）里面，可以是

基本类型：byte、char、short、int，

引⽤类型：String常量串、枚举类

不能是，long，double，float，boolean

Java输⼊输出⭐️⭐️⭐️

1，输出

java 复制代码

System.out.println(msg); //输出⼀个字符串,带换⾏           
System.out.print(msg); //输出⼀个字符串,不带换⾏             
System.out.printf(format, msg);//格式化输出

2，输入（难点）

1，导包

2，用Scanner创建一个对象sc，（sc类似于C语言的句柄）

3，创建变量=sc.什么，取决于你要输入的类型，

4，前两步一般只要做一次

5，最后要sc.close关掉

java 复制代码

import java.util.Scanner;  // 需要导⼊util 包
 
Scanner sc = new Scanner(System.in);
System.out.println("请输⼊你的姓名：");
String name = sc.nextLine();
System.out.println("请输⼊你的年龄：");
int age = sc.nextInt();
System.out.println("请输⼊你的⼯资：");
float salary = sc.nextFloat();
System.out.println("你的信息如下：");
System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"⼯资："+salary);
sc.close(); // 注意 要记得调⽤关闭⽅法

2，如何处理多组输⼊？

用到一个sc.hasNextInt()，使⽤ctrl+z来结束输⼊(Windows上的CMD中使⽤ctrl+z,Linux/Mac/IDEA的控制台上使⽤ctrl+d).

java 复制代码

while (sc.hasNextInt()) {
int tmp = sc.nextInt();
sum += tmp;
num++;
}

方法

java里的方法也就是C语言的函数。

通用模版

java 复制代码

public static int max(int a,int b){
    return a>b?a:b;
}

先这样写，为什么这样写后面我们会学习到

与C语言的主要区别

1. Java 方法必须写在类里面（最重要）
1. Java 没有"全局函数"
  例如，C语言有：

cpp 复制代码

  printf()
  scanf()

这种全局函数风格。但 Java：所有方法都属于：某个类某个对象，例如：

java 复制代码

Math.max()
Arrays.sort()

1. Java 没有函数声明（函数原型）
1. Java 参数传递只有"值传递"
1. Java 支持方法重载（重点）

由于期末考试一般不注重java的调试，所以，java的调试内容我就跳过了，想了解的可以问ai哦！

数组

数组的创建

就是在类型后面加方括号，等号后面加new 类型，c语言的创建方式同样适用但不建议！

java 复制代码

int[] arr = new int[10];
int[] arr = {1,2,3,4,5};
int[] arr = new int[]{1,2,3,4,5};
/*
该种定义⽅式不太友好，容易造成数组的类型就是int的误解[]如果在类型之后，就表⽰数组类型，因此int[]结合在⼀块写意思更清晰
 */
int arr[] = {1, 2, 3}；

数组的遍历

多了一个范围for和arr.length

java 复制代码

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}

java 复制代码

int[] array = {1, 2, 3};
for (int x : array) {
System.out.println(x);
}

数组是引用数据类型

基础数据类型和引用数据类型的区别

基本类型变量与引⽤类型变量的区别

1，基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值 ；

2，⽽引⽤数据类型创建的变量，⼀般称为对象的引⽤，其空间中存储的是对象所在空间的地址

比如，对于下面这段代码

java 复制代码

public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}

数组的传参和做返回值都是地址的形式

操作数据⼯具类Arrays

数组转字符串.toString

Array.toString

java 复制代码

import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
// 
执⾏结果
 
[1, 2, 3, 4, 5, 6]

数组拷⻉ .copyOf

java 复制代码

import java.util.Arrays;
public static void func(){
// newArr
和
arr
引⽤的是同⼀个数组
 
// 
因此
newArr
修改空间中内容之后，
arr
也可以看到修改的结果
 
int[] arr = {1,2,3,4,5,6};
int[] newArr = arr;
newArr[0] = 10;
System.out.println("newArr: " + Arrays.toString(arr));
// 
使⽤
Arrays
中
copyOf
⽅法完成数组的拷⻉：
 
// copyOf
⽅法在进⾏数组拷⻉时，创建了⼀个新的数组
 
// arr
和
newArr
引⽤的不是同⼀个数组
 
arr[0] = 1;
newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
// 
因为
arr
修改其引⽤数组中内容时，对
newArr
没有任何影响
 
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));
// 
拷⻉某个范围
. 
int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));
}

查找数组中指定元素(顺序查找).find

java 复制代码

public static void main(String[] args) {
int[] arr = {1,2,3,10,5,6};
System.out.println(find(arr, 10));
}
public static int find(int[] arr, int data) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == data) {
return i;
}
}
return -1;  // 
表⽰没有找到
 
}
// 
执⾏结果
 
3

查找数组中指定元素(⼆分查找).binarySearch

数组必须有序

java 复制代码

public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
System.out.println(binarySearch(arr, 6));
}
public static int binarySearch(int[] arr, int toFind) {
int left = 0; 
int right = arr.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (toFind < arr[mid]) {
// 
去左侧区间找
 
right = mid - 1;
} else if (toFind > arr[mid]) {
// 
去右侧区间找
 
left = mid + 1;
} else {
// 
相等
, 
说明找到了
 
return mid;
}
}
}
// 
循环结束
, 
说明没找到
 
return -1;
// 
执⾏结果
 
5

数组排序(冒泡排序).sort

java 复制代码

public static void main(String[] args) {
int[] arr = {9, 5, 2, 7};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}

数组逆序.reverse

java 复制代码

public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static void reverse(int[] arr) {
int left = 0;
int right = arr.length - 1;
while (left < right) {
int tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
left++;
right--;
}
}

⼆维数组

记住一点，二维数组就是一维数组存了一个数组的地址

java 复制代码

int[][] arr = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};

不规则的⼆维数组

java 复制代码

int[][] array = new int[2][];
array[0] = new int[3];
array[1] = new int[5];

下期预告

OK，今天的博客先分享到这里，下一期我们将一起学习java里面的类和对象咯，这才是真正与c语言不同的地方！！！！

结语

** 本文到此结束，欢迎各位在评论区探讨交流。需要快速复盘、精简学习内容的朋友，别忘了订阅我的快速复习专栏哦，主打专注整合学习中的精华，我们一起加油吧！**