进击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);
	}
}

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