Java学习笔记(day02)
基本运算符(假设A = 20; B = 10)
- 算术运算符
| 操作符 | 描述 | 例子 |
|---|---|---|
| + | 加法 - 相加运算符两侧的值 | A + B 等于 30 |
| - | 减法 - 左操作数减去右操作数 | A – B 等于 -10 |
| * | 乘法 - 相乘操作符两侧的值 | A * B等于200 |
| / | 除法 - 左操作数除以右操作数 | B / A等于2 |
| ％ | 取余 - 左操作数除以右操作数的余数 | B%A等于0 |
| ++ | 自增: 操作数的值增加1 | B++ 或 ++B 等于 21 |
| -- | 自减: 操作数的值减少1 | B-- 或 --B 等于 19 |
- ++a , a++ 的区别
public class Test {
public static void main(String[] args) {
int i = 10;
int j = 10;
int b;
int c;
/*
b = ++i;
其实就相当于以下两句代码:
i = i+1;
b = i;
*/
b = ++i;
System.out.println(b);
/*
c = j++;
其实就相当于以下两句代码:
c = j;
j = j+1;
*/
c = j++;
System.out.println(c);
}
}
输出结果:
11
10
Process finished with exit code 0
简单理解就是: ++在前, 就先自增, 用自增后的值去做运算; ++在后, 就先去做运算或者赋值,然后再自增
- 关系运算符
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）为假。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （A> = B）为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真。 |
- 位运算符
| 操作符 | 描述 |
|---|---|
| ＆ | 如果相对应位都是1，则结果为1，否则为0 |
| | | 如果相对应位都是 0，则结果为 0，否则为 1 |
| ^ | 如果相对应位值相同，则结果为0，否则为1 |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。 |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 |
| >>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 |
A = 20; B = 10;
二进制:
A: 0001 0100
B: 0000 1010
A&B: 0000 0000
A|B: 0001 1110
A^B: 0001 1110
~B: 1111 0101
A<<2: 0101 0000
A>>2: 0000 1010
<< : 相当于*2
>> : 相当于/2
位运算的效率高
面试题: 求2^3 = 8效率最高的方法: 2<<2
public class Test {
public static void main(String[] args) {
System.out.println(2 << 2);
}
}
输出结果:
8
Process finished with exit code 0
- 逻辑运算符(布尔变量A为true，变量B为false)
| 操作符 | 描述 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | （A && B）为假。 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | （A | | B）为真。 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | ！（A && B）为真。 |
&& 也叫做短路与, 当左边的条件为false时, 不会再去看右边的条件是否为真
- 赋值运算符
| 操作符 | 描述 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| + = | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
| - = | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
| * = | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
| / = | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C / = A，C 与 A 同类型时等价于 C = C / A |
| （％）= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C％= A等价于C = C％A |
| << = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
| >> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
| ＆= | 按位与赋值运算符 | C＆= 2等价于C = C＆2 |
| ^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| | = | 按位或赋值操作符 | C | = 2等价于C = C | 2 |
- 条件运算符
public class Test {
public static void main(String[] args) {
/*
格式: 表达式A ? 表达式B : 表达式C
当表达式A为true时,执行表达式B,为false时执行表达式C
*/
System.out.println(1+1 == 2 ? "1+1=2" : "1+1!=2");
}
}
输出结果:
1+1=2
Process finished with exit code 0
- instanceof运算符
用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）.
instanceof运算符使用格式如下：
( Object reference variable ) instanceof (class/interface type);
Scanner
/*java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。
常用的两个方法:
next(): 不能接收含有空格的字符串,遇到空格结束.
nextline(): 能接收含有空格的字符串,遇到回车结束.
*/
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入:");
if(sc.hasNextLine()){
System.out.println(sc.nextLine());
}
sc.close();
}
}
输出结果:
请输入:
hahaha
hahaha
Process finished with exit code 0
java循环
public class Test {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6};
System.out.println("==============for===============");
for (int i = a.length - 1; i >= 0; i--) {
System.out.print(a[i]);
}
System.out.println("\n");
System.out.println("==============while===============");
int j = a.length - 1;
while(j >= 0){
System.out.print(a[j]);
j--;
}
System.out.println("\n");
System.out.println("==============do while===============");
int c = a.length - 1;
do {
System.out.print(a[c]);
c--;
}while (c>=0);
System.out.println("\n");
System.out.println("==============增强for===============");
for (int e:a) {
System.out.print(e);
}
}
}
==============for===============
654321
==============while===============
654321
==============do while===============
654321
==============增强for===============
123456
Process finished with exit code 0
do…while循环至少会执行一次循环体.
for循环和while循环只有在条件成立的时候才会去执行循环体.
for循环语句和while循环语句的小区别：使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率
java方法
定义
-
Java方法是语句的集合，它们在一起执行一个功能
-
方法是解决一类问题的步骤的有序组合
-
方法包含于类或对象中
-
方法在程序中被创建，在其他地方被引用
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
方法的优点
- 使程序变得更简短而清晰
- 有利于程序维护
- 可以提高程序开发的效率
- 提高了代码的重用性
方法的重写
- 方法名, 参数必须一致.
- 修饰符, 范围可以扩大不能缩小
- 抛出异常的范围不能扩大, 只能缩小
方法的重载
-
方法名相同, 但是必须拥有不同类型, 个数的参数,
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表.
Java编译器根据方法签名判断哪个方法应该被调用.
方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字.
重载的方法必须拥有不同的参数列表. 你不能仅仅依据修饰符或者返回类型的不同来重载方法.
方法的值传递和引用传递
- java 基本数据类型传递参数时是值传递 ；引用类型传递参数时是引用传递
- 值传递不会改变原有的值
- 引用传递,如果在方法中改变了传递进来的引用数据, 原来的也就跟着变化了
递归
说得简单一些就是一个方法自己调用自己, 必须有一个能够结束调用的条件, 否则一直调用会造成栈溢出.
public class Test {
public static void main(String[] args) {
System.out.println(jieCheng(5));
}
private static int jieCheng(int i){
/*
计算阶乘
5! = 5*4*3*2*1;
*/
if (i == 1){ // 结束调用自己的条件
return 1;
} else {
return i * jieCheng(i-1);
}
}
}
输出结果:
120
Process finished with exit code 0
/*
有50瓶饮料，喝完后每三个空瓶子可以换一瓶，问总共可以喝多少瓶饮料？
*/
public class Test {
public static void main(String[] args) {
System.out.println(drink(50));
}
private static int drink(int i){
/*
5! = 5*4*3*2*1;
*/
if (i < 3){
return i;
} else {
return i + drink(i/3 + i%3);
}
}
}
输出结果:
76
Process finished with exit code 0
数组
-
数组: 相同类型的 数据的一组有序集合, 其中每一个数据叫做数组的一个元素, 可以通过索引来访问每一个元素, arr[0]就代表数组的第一个元素, arr[arr.length - 1]代表最后一个元素. 0<=数组的索引<=数组的长度-1, 不在这个范围将会引发数组越界异常
-
数组的声明和创建:
类型[] 数组名 = new 类型[length];
类型[] 数组名 = {数组元素1,数组元素2,数组元素3...};
类型 数组名[] = {数组元素1,数组元素2,数组元素3...};
Arrays类
java.util.Arrays类是Java提供的工具类,专门用于操作数组.常用的方法如下:
- sort() 排序
- fill 给数组元素值
- copyof()
- toString() 将数组转化成字符串输出
- asList(T... a) 返回由指定数组支持的固定大小的列表。