Java学习笔记二

1.运算符

1.1概述

1.1.1）算数运算符： + - * / % ++ –

注意事项：
	 +  -  *   /  两端的变量必须是同种类型，并返回同种类型。
	 % 取余运算，负数的余数符号与被模数符号相同，- 1 % 5 = - 1，1 % - 5 = 1；Num % n， n>0，结果范围 [0,n)，是周期函数。
	 **注意整除**问题： 1 / 2 = 0（整数的除法是整除）	1.0 / 2 = 0.5 1D / 2 = 0.5
	 单独的前、后自增或自减是没区别的， 有了赋值语句或返回值， 则值不同！

eg1自增自减

int a = 1; a = a++; System.out.println("a 的值： "+a);
第 1 步：后 ++，先确定表达式 a++的值（当前 a 的值） a++ ---->1
第 2 步： ++，给 a 加 1
第 3 步：最后赋值运算 ,把 a++整个表达式的值赋值给 a a ---->1
a 被赋值两次，第 1 次 a = 2，第 2 次把 1 赋值给 1

eg2自增自减

x，y， z分别为 5，6， 7 计算 z + = – y * z++ ；// x = 5 ， y = 5，z = 42
z = z + – y * z++ 42 = 7 + 5 * 7 从左到右入栈，入的是值

eg3取出数字的每一位

d = num%10;// 获取 num 的最后一位数 num/=10; // 消除 num 的最后一位

1.1.2）位运算： & | ~（取反） ^（异或） >><<>>>

** 注意事项：**
一个数异或同一个数两次，结果还是那个数。
一个数异或同一个数两次，结果还是那个数。
| ：上下对齐，有 1 个 1 则为 1；&：上下对齐，有 1 个 0 则为 0；（都为二进制）
&相当于乘法， | 相当于加法； &：有 0 则为 0，| ：有 1 则为 1，^：两数相同为 0，不同为 1。

public class Test1 {
   public static void main(String[] args) {
	  int a = 5;
	   System.out.println(a+=2);
	  //逻辑与算符
	      //  1. &&:双与   表示并且关系 (效率高)  /     &   表示并且关系
	   		
	     //   2. ||:双或   表示或者关系 (效率高)  /     |   表示或者关系
	   
	   
	 //练习题1.自增++   自减--          
	   int b = 2;
	 //符号在后，先使用后变化
	   System.out.println(b++);  
	   int c = 2;
	 //符号在前，先变化在使用
	   System.out.println(++c); 
	   System.out.println(++c+b+c++); 
	   System.out.println(b);
	   System.out.println(c);
	   int d = 0;
	   int e = 0;
	   System.out.println(d--);
	   System.out.println(--e);
	   System.out.println(--d-e-e--);//-2-(-1)-(-1)=0
	  
   }
}

1.1.3）关系运算符： ><>= <= == !=

1.1.4）逻辑运算符： && || （短路） ! & |

短路运算： && ：前为 flase，则后面不计算； || ：前为 true ，则后面不计算

int x=1,y=1,z=1;
if(x–==1 && y++==1 || z++==1) // || 短路运算后面的不执行了！
System.out.println( “ x=” +x+” ,y= ” +y+0 , 2, 1 ” ,z= ” +z);//

1.1.5）赋值运算符： = += -= *= /= %=

正负 1 交替

int flag= -1; System.out.println(flag*=-1);

1.1.6）条件（三目）运算符：表达式 1 ？ 表达式 2 ：表达式 3

注意事项：
右结合性： a > b ? a : i > j ? i : j 相当于 a > b ? a : ( i > j ? i : j )
三目运算符中：第二个表达式和第三个表达式中如果都为基本数据类型，
整个表达式的运算结果由容量高的决定。如： int x = 4; x > 4 ? 99.9 : 9;
99.9 是 double 类型，而 9 是 int 类型， double 容量高，所以最后结果为9.9。

public class Test2 {
	public static void main(String[] args) {
		//定义变量，记录大值
			//三元运算符     1 ？2：3     解释：如果1成立就是2   如果1不成立就是3
		System.out.print("请输入a的值：");
		int a = new Scanner(System.in).nextInt();
		System.out.print("请输入b的值：");
		int b = new Scanner(System.in).nextInt();
		System.out.print("请输入c的值：");
		int c = new Scanner(System.in).nextInt();
		int max = a>b?a:b;
		System.out.println("a,b的最大值是："+max);
		max = max>c?max:c;
		System.out.println("a,b,c的最大值是："+max);
		max = a>b?(a>c?a:c):(b>c?b:c);
		System.out.println("新的a,b,c的最大值是："+max);
	}
}

1.1.7） 运算符优先级：

括号 > 自增自减 > ~ !> 算数运算符 > 位移运算 > 关系运算 > 逻辑运算 > 条件运算 > 赋值运算

1.1.8） 练习

1.1.8.1练习1：平年闰年

输入年号，判断是否是闰年。两个条件：
1、能被4整除，并且不能被100整除
2、或者能被400整除

public class Test1 {
       public static void main(String[] args) {
              System.out.println("年号：");
              int y = new Scanner(System.in).nextInt();
              String r="平年";
              if(y%4==0){
                     if(y%100!=0){
                            r="闰年";
                     }
              }
              if(y%400==0){
                     r="闰年";
              }
或者
if((y%4==0&&y%100!=0)||y%400==0){
                     r="闰年";
 }
              System.out.println(y+"年是"+r);
       }
}

1.1.8.2求三个数的最大值

public class Test1_三个数的最大值 {
       public static void main(String[] args) {
              System.out.println("整数a:");
              int a = new Scanner(System.in).nextInt();
              System.out.println("整数b:");
              int b = new Scanner(System.in).nextInt();
              System.out.println("整数c:");
              int c = new Scanner(System.in).nextInt();
int max = a>b?a:b;
             max=max>c?max:c;

或者
int max = a>b?(a>c?a:c):(b>c?b:c);
              System.out.println(max);
       }
}

2.流程控制语句

2.1选择控制语句

if 语句： if 、if-else、if-else-if ：可以处理一切分支判断。
格式如下：

单分支：

if(判断条件){
       代码。。。
}

多分支：

if(判断条件){
       代码1。。。
}else{
       代码2。。。
}

嵌套分支：

if(判断条件1){
       代码1。。。
}else if(条件2){
       代码2。。。
} else if(判断条件3){
       代码3。。。
}else{
       代码4。。。
}

switch 语句：当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束。
switch 语句形式 switch(expr1)中,expr1是一个整数表达式， 整数表达式可以是int基本类型或Integer包装类型,由于byte,short,char都可以隐含转换为int，所以也支持。
注意： jdk1.7以后新增 String

switch(变量或者表达式){
       case 1:
       case 2:
       case 3:  
	   case 4:  
       default:
}

注意事项：int 类型指： byte、short 、 int，只能写 long 类型，要写也必须强转成 int类型；；而 byte、 short 为自动转换成 int 。
swtich-case：若 case中无符合的数， 并且 default 写在最前（无 break 时），则为顺序执行，有 break 或 } 则退出。
swtich-case：若 case中无符合的数， 并且 default 写在最后，则执行 default 。
swtich-case：若 case中有符合的数，并且 default 写在最后，并且 default前面的 case 没有 break 时， default 也会执行

练习

练习1：商品打折

接收用户输入的原价。满1000打9折。满2000打8折。满5000打5折。

public class ttt {
       public static void main(String[] args) {
              System.out.println("输入总原价");
              double price = new Scanner(System.in).nextDouble();
              double now = f(price);
              System.out.println(now);
       }
       public static double f(double p){
              if(p>5000){
                     p=p*0.5;
              }else
              if(p>2000){
                     p=p*0.8;
              }else if(p>1000){
                     p=p*0.9;
              }
              return p;
       }
}

练习2：统计学员得分

90分以上 优秀
80~89 良好
70~79 中等
60~69 及格
60分以下 不及格

public class aa {
    public static void main(String[] args) {
       double score = new Scanner(System.in).nextDouble();
       if (score >= 100 || score <= 0) {
           System.out.println("请输入0~100以内的值");
       }
       if (score > 90 && score <= 100) {
           System.out.println("优秀");
       } else if (score >= 80 && score <= 90) {
           System.out.println("良好");
       } else if (score >= 70 && score <= 79) {
           System.out.println("中等");
       } else if (score >= 60 && score <= 69) {
           System.out.println("及格");
       }else if (score < 60) {
           System.out.println("不及格");
       }
    }
}

2.2）循环控制语句

1.for：最常用，用在与次数有关的循环处理， 甚至只用 for 可以解决任何循环问题。
注意事项： for 中定义的用于控制次数的循环变量，只在 for 中有效， for结束则循环变量被释放（回收）

for(开始条件；循环条件；更改条件){
       循环体代码…
}

嵌套for循环

for(…){
       for(…){
		}
}

2.while ：很常用， 用在循环时候要先检查循环条件再处理循环体， 用在与次数无关的情况。 如果不能明确结束条件的时候， 先使用 while(true) ，在适当条件使用 if 语句加 break结束循环。先判断，再执行

while(执行条件){
       代码…
}

3.do-while ：在循环最后判断是否结束的循环。如：使用 while(true) 实现循环的时候，结束条件 break 在 while 循环体的最后，就可以使用 do-while 。do-while 的结束条件经常是“否定逻辑条件” ，不便于思考业务逻辑， 使用的时候需要注意。 可以利用 while（ true ）+ break 替换。** 先执行，再判断**

do{
       代码…
}while(执行条件);

4.循环三要素： A．循环变量初值 B．循环条件 C．循环变量增量（是循环趋于结束的表达式）
5.for 和 while 循环体中仅一条语句，也要补全 { }，当有多条语句，且不写 { }时，它们只执行紧跟着的第一条语句。
6.循环的替换：
while( 布尔表达式 ){} 等价 for(布尔表达式 ){}
while(true){} 等价 for()
while(true){} + break 替换 do{}while( 布尔表达式 );
for() + break 替换 do{}while( 布尔表达式 );

2.3跳转控制语句

continue ：退出本次循环，直接执行下一次循环

for(){
       代码1
if(条件){
    代码3…
    continue;//如果成立，跳出本次for循环，进入下一轮
}
代码2…
}

break：退出所有循环；break: 中断当前循环，简单粗暴

for(){
       代码1
if(条件){
  代码3…
    break;//如果成立，直接跳出这个for循环
}
代码2…
}

3.数组

3.1概念

数组Array是用于储存多个相同类型数据的集合。
想要获取数组中的元素值，可以通过元素的下标来获取，下标是从0开始的。

3.2创建数组

一般分为动态初始化和静态初始化
动态初始化：int[] a = new int[5];

新建int[],长度是5
刚创建好的数组都是默认值0，int类型的数据默认值是0
把数组的地址值给变量a保存

静态初始化1：int[] a ={1,2,3,4,5,6,7,8};
静态初始化2：int[] a =new int[]{1,2,3,4,5};
总结：数组（数组对象）有 3 种创建（初始化）方式：

3.3 数组的长度

length属性获取数组长度
数组一旦创建，长度不可变
允许0长度的数组

3.4数组的遍历

从头到尾，依次访问数组的位置。

3.5形式

for(int i=0;i<a.length;i++){
       System.out.println(a[i]);
}

4.数组工具类Arrays

4.1 Arrays.toString(数组)

把数组里的数据，用逗号连接成一个字符串。
格式：[10, 14, 20, 46, 51]

4.2Arrays.sort(数组)

对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
对引用类型数组，使用优化后的合并排序算法。

4.3Arrays.copyOf(数组，新的长度)

把数组复制成一个指定长度的新数组。
新数组长度大于原数组，相当于复制，并增加位置。–数组的扩容
新数组长度小于原数组，相当于截取前一部分数据。–数组的缩容

4.4测试

int[] a = Arrays.copyOf(arr, 10);//数组的复制，大于原来长度相当于扩容

System.out.println(Arrays.toString(a));//[12, 30, 20, 90, 34, 0, 0, 0, 0, 0]

System.out.println(a.length);//10       

int[] a2 = Arrays.copyOf(arr, 3);//数组的复制，晓宇原来长度相当于截取前几个数据

System.out.println(Arrays.toString(a2));//[12, 30, 20]

System.out.println(a2.length);//10

4.5 补充说明

4.5.1数组元素的访问：

①数组长度：长度使用属性访问， ary.length 获取数组下标。
②数组下标：范围： 0 ~ length-1 就是 [0,length) ，超范围访问会出现下标越界异常。
③使用 [index]访问数组元素： ary[2] 。
④迭代（遍历） ：就是将数组元素逐一处理一遍的方法。

4.5.2数组默认初始化值：

根据数组类型的不同，默认初始化值为： 0（整数）、0.0（浮点数）、false（布尔类型） 、\u0000 （char 字符类型，显示无效果，相当于空格，编码为 0 的字符，是控制字符，强转为 int 时显示 0）、null（ string 类型，什么都没有，空值的意思） 。