进击JAVA——twoday

时间：2019.10.27 (float )(b/a)是先计算后转结果，(b/a(float))是先转数值后计算

public class HelloWorld{ public static void main(String[] args){ int a=13; int b=45; System.out.println((float)b/a); System.out.println(b/a); } }

运行结果：

3.4615386 3

b++:先用b,然后再+1；++b:先+1，而后1； 　　例如：

int b=4,i=3; int c=b-- + ++i - --b*i++;

分析：c=4+4-2*4;此类表达式在书写时要懂得断句。 　　运行结果为0； 在同一运算符之间单目运算符优先级高于多目运算符 左移右移问题，左移表示原来的数乘以2，往右移表示原来的数除以2.如byte b=-128,右移8为为-1.

public class HelloWorld { public static void main(String[] args){ boolean foo=false; int b=0; int c=1; int d=b>c?b:c; System.out.println(d); byte b=-128; int a=b>>1; byte b=9; byte a=7; System.out.println(a^a); 　　　　　　　　　 int a=-4; int b=5; int c=b/a; float d=4.3f; int s=d; System.out.println(c); System.out.println(s); int a=3+4; System.out.println(a); int b; int i=b=3; System.out.println(++i); } }

if(foo)等同于if(foo=true); 关系运算符：int b=0;int c=1;int d=(b>c)?b:c; 流程控制：顺序流程，分支语句控制（如if，switch），递归（属于循环的一种）

public class Testfor{ public static void main (String[] args) { int a=100; int b=4; do { System.out.println("a"); }while(b>a); } }

运行结果：a

if 格式： if（字面量为blooean类型的表达式或方法或者变量） 代码块 switch格式：

switch(){case: 　　　　　　　　　　　break; 　　　　　　　　　　　case: 　　　　　　　　　　　break; 　　　　　　　　　　　default: 　　　　　　　　　　　break;}

switch()中不能用long float boolean类型（java1.7版本以前不能用String类型） break是结束当前代码块,从代码块外开始执行；coninue是回归循环体的循环条件； for格式 for(1.数据初始化部分；2.条件判断部分；3.条件改变部分) 循环体 注：没有条件也可以，两个分号必须有。 浮点数的二进制：例: 69.88: 64+4+1 0100 0101 1110 0000 0001 0100 01 0.882 1.76.0.762 1.52 0.522 1.04 0.0422222 1.28 0.2822 1110 0000 0001 0100 01 0 1000 0010 1000 1011 1100 0010 1000 111 0 1000 0101 0001 0111 1000 0101 0001 111

已知重复次数用for;不知重复次数时用while; 对于容器操作，一般分为三种操作类型：定位，替换，求长。 目前我们看到的是数组，数组的定位，替换，求长分别是，

public class Sum { public static void main(String[] args) { int[] arrays = {1,4,3,8,5,16,7}; int max = 0; int index = 0; for(int i =0; i<arrays.length; i++) { if(max < arrays[i]) { max = arrays[i]; index = i; } } System.out.println(index); } } int[] arrays=new int [6];

//数组的定位

int item=arrays[4]; int item2=arrays[6]; int item3=arrays[-1];

错误，[]内不能为负数。 //数组的替换

arrays[3]=100;

//求长

int length=arrays.length;

数组遍历:定位求长替换

for(int item:result){ System.out.print(item) }

数组反转：1.新建新的数组做反转

for(int j=0;j<arrays.length;j++) result[j]=arrays[arrays.length-1-j];

2.在原有基础上做反转，不新建新的数组

for(int j=0;j<i;j++) int temp=arrays[j]; arrays[j]=arrays[arrays.length-1-j]; Arrays[arrays.length-1-j]=temp;

数组在创建之初应设置其大小(而后大小不能改变)和角标(从0开始计数)； 数组中的new总是开辟新空间； 数组中的内存是连续的； 排序：两个for循环的嵌套：外层for负责确定循环中需要替换的位，内存负责比较 直接排序：

import java.util.*; public class DSort{ public static void main(String[] args){ int[] arrays={56,78,33,26,99,103,52,44}; for(int i=0;i<arrays.length;i++){ for (int j=0;j<arrays.length;j++){ if (arrays[i]>arrays[j]){ int temp=arrays[j]; arrays[j]=arrays[i]; arrays[i]=temp; } } } System.out.println(Arrays.toString(arrays)); } }

运行结果：[103,99,78,56,52,44,33,26]

选择排序：

import java.util.*; public class SSort{ public static void main(String[] args){ int[] arrays={56,78,33,26,99,103,52,44}; for(int i=0;i<arrays.length;i++){ int max=arrays[i]; int index=i; for (int j=i;j<arrays.length;j++){ if(max<arrays[j]){ max=arrays[j]; index=j; } } max=arrays[i]; arrays[i]=arrays[index]; arrays[index]=max; } System.out.println(Arrays.toString(arrays)); } }

运行结果：[103,99,78,56,52,44,33,26]

冒泡排序：

import java.util.*; public class BSort{ public static void main(String[] args){ int[] arrays={56,78,33,26,99,103,52,44}; for(int i=0;i<arrays.length;i++){ for (int j=0;j<arrays.length-i-1;j++){ if(arrays[j]<arrays[j+1]){ int temp=arrays[j]; arrays[j]=arrays[j+1]; arrays[j+1]=temp; } } } System.out.println(Arrays.toString(arrays)); }

运行结果：[103,99,78,56,52,44,33,26]

二维数组：数组的动态初始化过程：int[][] arrays= new int[5][5]; 数组的静态初始化过程： int[][] arrays1={{1,2,3},{4,5,6},{7,8,9}};`

import java.util.*; public class test2{ public static void main(String[] args){ //数组的动态初始化过程 int[][] arrays=new int [5][5]; //数组的静态初始化过程 int[][] arrays1={ {1,2,3}, {2,3,4,5,2,6}, {4,3}, {2,3,4,86,45,5,7} }; System.out.println(arrays1); } }

内存碎片由垃圾回收机制处理；