Java学习笔记(Javase毕向东版视频)二.2

 1 class test
 2 {
 3     public static void main(String[] args)
 4     {
 5         //赋值运算符 =(赋值) +=,-=,*=,/=
 6         int a=1234,b;
 7 
 8         /*算数运算符 +(加) -(减) *(乘) /(除) %(取余) ++(自增) --(自减) +(字符串连接)
 9          *1、除法运算结果自动转换为int型。
10          *2、取余结果的正负取决于被除数
11          *3、任何类型变量和 字符串 进行+操作,都是连接操作,结果为字符串类型
12          *4、++和--如果在变量前先运算再自增(减);在变量后则相反。这里的先后是在有其他运算时,否则效果相同
13          */
14         a=a/-1000*1000;
15         a=a%333;
16         b=++a;
17         System.out.println("a="+a);
18         /*
19          *a+=1==>a=a+1,其他赋值运算类似;
20          *但是有一点需要注意:前者是赋值运算,后者是算术运算+赋值运算
21          *！！！赋值运算在赋值前会进行类型检测,如果类型内存较高,就会强制类型转换而且进行高位去除
22          *！！！而算数运算符在有变量进行计算时不能确定类型,就会使用默认类型
23          *！！！总结:两者区别在于前者自动强制转换
24         */
25 
26         /*
27          *比较运算符 ==(等于) !=(不等于) >(大于) <(小于) >=(大于等于) <=(小于等于) instanceof(是否是类的对象)
28          *运算都有结果,比较运算的结果是true或false,即boolean值。
29         */
30         System.out.println(3>2);
31 
32         /*
33          *逻辑运算符:用于连接两个boolean类型的表达式
34          *  &(与,一假则假)  |(或,一真则真)   !(非,取反) ^(异或,两边不同则真)
35          *  &&(与,一假则假) ||(或,一真则真)
36          *！！！单双&|的区别在于
37          *1、后者有短路效果,即当满足判断条件(&时第一个为假,|时第一个为真)时,后面的表达式不进行计算
38          *2、&,|还可以用位运算,而&&,||更常用连接boolean表达式
39          *
40          *
41         */
42         int c=3;
43         System.out.println(c>2&c<5);
44             /*
45              *！！！异或有一个特点:一个数异或另一个数两次,得到自身值
46              *有一个例子就是不用第三个变量交换两变量的值
47             */
48             c=c^3^3;
49             System.out.println("c="+c);
50             int d=3,e=5;
51             System.out.println("开始时d="+d+",e="+e);
52             d=d^e;
53             e=d^e;
54             d=d^e;
55             System.out.println("交换后d="+d+",e="+e);
56 
57         /*
58          *位运算符:用于对数据按位byte进行运算,详见下图
59         */
60         System.out.println(~6);
61 
62         /*
63          *三元运算符:(条件表达式)？表达式1:表达式2
64          *条件表达式结果为真,运算结果为表达式1;否则为表达式2。
65         */
66 
67     }
68 }

 1 class test
 2 {
 3     public static void main(String[] args)
 4     {
 5         //循环结构就是一条条语句从上到下排列,一条语句以;结束。
 6 
 7         /*
 8          *选择结构是将条件表达式的值进行判断,如果为真则执行指定语句,(否则执行另一部分语句)
 9          *有if和switch两种:
10          *if用于    1、对具体值判断,2、对区间判断,3、对boolean类型表达式判断
11          *switch用于1、对具体值判断,2、值的个数确定(非区间)3、
12         */
13         int a=3;
14         if(a>5){
15             System.out.println("a大于5");
16         }else if(a>3){
17             System.out.println("a小于5但大于3");
18         }else{
19             System.out.println("a小于3");
20         }
21         /*1、switch代码块中的顺序没有关系,但是执行时会先按顺序执行case语句,最后执行default语句
22          *2、break用于结束case语句和default语句,如果在}之前省略,后面还有代码,即使已经正确,
23          *   还是会向后执行直到break或者}
24         */
25         switch(a){
26             default:
27                 System.out.println("a非1,3,5");break;
28             case 3:
29                 System.out.println("a等于3");
30             case 1:
31                 System.out.println("a等于1");break;
32             case 5:
33                 System.out.println("a等于5");break;
34         }
35 
36         /*
37          *循环结构:while,do...while,for
38          *需要控制:1、循环条件,2、循环体。
39          *格式见下图
40          *！！！for和while的区别在于:
41          *for中的初始化表达式中可以进行变量定义,而且这个变量只在循环内部有效
42          *while中则只能用外部定义的变量,所以循环之后不能销毁,如果只用一次会浪费内存
43         */
44 
45         //上面的语句可以嵌套使用
46 
47         /*
48          *Java的代码是保存在代码块中的,即{}之中,最简单是下面这种单独的代码块
49          *还有就是上面依附在if,switch,while之后的代码块,依附在函数/类之后的代码块
50          *！！！代码块在遇到和开始的{对应的}时就会将生成的变量空间释放,即销毁变量
51          *所以代码块内可以访问外部代码块中的变量,但是外部不能访问内部变量。
52          *！！！并且注意代码块内部同样不能重复前面定义过的变量,但是可以在其后重新使用该变量标识。
53          *
54          *由于用后即销毁的特性,可以节省内存,如果当变量只用一次时可以节约空间,因为Jvm内存有限。
55         */
56         {
57             int i=2;
58             System.out.println("i="+i);
59         }
60         int i=3;
61         System.out.println("i="+i);
62 
63     }
64 }

 1 public class test {
 2     public static void main(String[] args){
 3         int n=0,a=1,b=100;
 4         while(a<b){
 5             if(a%6==0){
 6                 n+=1;
 7             }
 8             a++;
 9         }
10         System.out.println(n);
11         
12         for(int x=1;x<=9;x++){
13             for(int y=1;y<=x;y++){
14                 //\t是转义字符 制表符,制表符的效果就是 对其显示
15                 System.out.print(y+"*"+x+"="+(x*y)+"\t");
16             }
17             System.out.println();
18         }
19         
20         for(int x=1;x<=5;x++){
21             for(int y=5;y>=x;y--){
22                 System.out.print(y);
23             }
24             System.out.println();
25         }
26         
27         //倒三角形,可以看做两个三角形的组合,一个由空格组成,就是效果中的-，另一个是*空格构成
28         for(int x=1;x<=5;x++){
29             for(int y=1;y<x;y++){
30                 System.out.print(‘-‘);
31             }
32             for(int z=x;z<=5;z++){
33                 System.out.print("* ");
34             }
35             System.out.println();
36         }
37     }
38 }

 1 public class Function {
 2         //！！！注意Java中不允许嵌套函数。
 3         
 4         //main函数没有返回值,用void标示,即空,这是特殊的返回值。可以用return;来结束函数块,也可以直接省略
 5         public static void main(String[] args){
 6             int a=3,b=4,c;
 7             c=add(a,b);
 8             System.out.println(c);
 9             draw(2,2);
10         }
11         
12         /*！！！需要注意的几点
13          * 1、这里有一点需要注意:就是由static修饰的函数调用的函数必须也要用static修饰,稍后解释
14          * ！！！2、函数的参数就相当于函数代码块的局部变量,初始化过程在调用时进行,当函数块结束局部变量消失
15          * ！！！而且Java中不允许普通变量的引用传递(即&a的使用方式);只能传值赋值,即将值复制一份赋值
16          * ！！！引用和传值的区别是:只要引用的关系存在,变量就不会消失
17          * 3、函数封装一定要明确要求,不要过度操作,像下面如果只要和的返回值,就不要输出。
18          */
19         static int add(int a,int b){
20             return a+b;
21         }
22         
23         /*
24          * 同一个类中,变量标识符不能多次使用,但是函数标识符可以,只要满足下面条件即可
25          * 1、参数个数不同,2、参数类型不同
26          * ！！！注意是判断参数而不是返回值
27          * 称为函数重载。Java会自动判断应该调用那个函数。
28          */
29         static int add(int a,int b,int c){
30             return a+b+c;
31         }
32         
33         static void draw(int a,int b){
34             if(a<=1||b<=1){
35                 System.out.println("不能构成矩形！");
36                 return;
37             }
38             for(int x=1;x<=a;x++){
39                 System.out.print("*");
40             }
41             System.out.println();
42             if(b>2){
43                 for(int z=1;z<=b-2;z++){
44                     System.out.print("*");
45                     for(int y=1;y<=a-2;y++){
46                         System.out.print(" ");
47                     }
48                     System.out.print("*");
49                     System.out.println();
50                 }
51             }
52             for(int x=1;x<=a;x++){
53                 System.out.print("*");
54             }
55         }
56 
57 }

 1 public class array {
 2     public static void main(String[] args){
 3         //main函数的参数就是字符串数组类型的,值是通过Java。exe运行时传入的
 4         //System.out.println(args[0]);
 5         
 6         /*数组的 定义有三种格式:其中[]为数组标识
 7          * 1、元素类型[] 数组名=new 元素类型[数组单元个数];
 8          * 2、元素类型[] 数组名=new 元素类型[]{值1,,值2,。。。};   注意不能再][]中标明数组个数
 9          * 3、元素类型[] 数组名={值1,,值2,。。。};
10          */
11         int[] arr={1,2,3};
12         
13         /*定义数组的主要目的就是 存/取 值
14          * 存值可以使用上面的2,3两种方式,也可以在定义后,通过 角标 来保存值
15          * 取值只能通过 角标 来进行,取值的一个常用操作就是遍历,通过循环控制角标来实现,
16          * 数组的角标是从0开始的
17          */
18         arr[2]=5;
19         for(int i=0;i<arr.length;i++){
20             System.out.println(arr[i]);
21         }
22     }
23 }

  1 public class arrayFunction {
  2     public static void main(String[] args){
  3         /*数组常见操作:
  4          * 1、获取最大/小值
  5          * 2、数组排序
  6          * 3、折半查找(二分查找)
  7          */
  8         int[] arr={123,2345,31,353,1,35,8111};
  9         int max=getMax(arr);
 10         System.out.println(max);
 11         //Arrays.sort(arr);
 12         bubbleSort4(arr);
 13         for(int i=0;i<arr.length;i++){
 14             System.out.println(arr[i]);
 15         }
 16         int [] arr1={123,234,345,456,567,678};
 17         int a=getIndex2(arr1,45);
 18         System.out.println(a);
 19     }
 20     
 21     public static int getMax(int[] arr){
 22         int max=arr[0];
 23         for(int i=1;i<arr.length;i++){
 24             max=max>arr[i]?max:arr[i];
 25         }
 26         return max;
 27     }
 28     
 29     
 30     /*选择排序:就是选择所有数中最小(大)值和最左端值交换;循环执行直到最后一个数
 31      * 和获取最大小值的不同点是需要知道该值的角标来进行交换操作
 32      */
 33     public static void selectSort(int[] arr){
 34         for(int i=0;i<arr.length;i++){
 35             int min=arr[i],min_index=i;
 36             for(int j=i+1;j<arr.length;j++){
 37                 if(min>arr[j]){
 38                     min=arr[j];
 39                     min_index=j;
 40                 }
 41             }
 42             if(min_index!=i){
 43                 swap(arr,min_index,i);
 44             }
 45         }
 46     }
 47     //冒泡排序:就是从左到右两两进行比较,大数放左,小数放右。最简单的是循环数组长度次,必然可以完全排序
 48     public static void bubbleSort1(int[] arr){
 49         for(int i=0;i<arr.length;i++){
 50             for(int j=0;j<arr.length-1;j++){
 51                 if(arr[j]<arr[j+1]){
 52                     swap(arr,arr[j],arr[j+1]);
 53                 }
 54             }
 55         }
 56     }
 57     //下面是冒泡排序的优化(for和while实现),即用一个标志来记录是否某次循环中进行了换位,如果没有表示完全排序,程序可以结束.
 58     public static void bubbleSort2(int[] arr){
 59         for(int i=0;i<arr.length;i++){
 60             boolean flag=false;
 61             for(int j=0;j<arr.length-1;j++){
 62                 if(arr[j]<arr[j+1]){
 63                     swap(arr,arr[j],arr[j+1]);
 64                     flag=true;
 65                 }
 66             }
 67             if(flag==false)
 68                 return;
 69         }
 70     }
 71     public static void bubbleSort3(int[] arr){
 72         boolean flag=true;
 73         while(flag){
 74             flag=false;
 75             for(int j=0;j<arr.length-1;j++){
 76                 if(arr[j]<arr[j+1]){
 77                     swap(arr,arr[j],arr[j+1]);
 78                     flag=true;
 79                 }
 80             }
 81         }
 82     }
 83     //这是冒泡算法的进一步优化,用flag标记进行转换的最大角标,之后的数已经排好了可以不进行下一轮排序
 84     public static void bubbleSort4(int[] arr){
 85         int k,flag=arr.length;
 86         do{
 87             k=flag;
 88             flag = 0;
 89                 for (int j = 0; j<k-1; j++)
 90                     if (arr[j] < arr[j+1])
 91                     {
 92                         int temp=arr[j];
 93                         arr[j]=arr[j+1];
 94                         arr[j+1]=temp;
 95                         flag = j+1;
 96                     }
 97         }while(flag>0);
 98     }
 99     //交换数组单元
100     public static void swap(int[] arr,int a,int b){
101         int temp=arr[a];
102         arr[a]=arr[b];
103         arr[b]=temp;
104     }
105     
106     
107     /*查找操作:
108      * 
109      */
110     public static int getIndex(int[] arr,int value){
111         for(int i=0;i<arr.length;i++){
112             if(arr[i]==value){
113                 return i;
114             }
115         }
116         //这里返回-1是因为规定返回值类型为int,如果没有找到该单元,则上面没有返回值,而此处的数必须为负数,因为角标为>=0,常用-1
117         return -1;
118     }
119     //二分法查找:数组单元值必须按顺序排列
120     public static int getIndex2(int[] arr,int value){
121         int min_index=0,max_index=arr.length-1,mid_index=(min_index+max_index)/2;
122         if(value<arr[min_index]||value<arr[max_index]){
123             return -1;
124         }
125         while(arr[mid_index]!=value){
126             if(arr[mid_index]>value){
127                 max_index=mid_index-1;
128             }else{
129                 min_index=mid_index+1;
130             }
131             if(arr[min_index]<value&arr[max_index]>value){
132                 return -1;
133             }
134             mid_index=(min_index+max_index)/2;
135         }
136         return mid_index;
137     }
138 }

public class ArrayFunction
{
    public static void main(String[] args){
        int a=60;
        toOctal(a);
    }
    public static void toHex(int num){
        char[] arr=new char[]{‘0‘,‘1‘,‘2‘,‘3‘,‘4‘,‘5‘,‘6‘,‘7‘,‘8‘,‘9‘,‘A‘,‘B‘,‘C‘,‘D‘,‘E‘,‘F‘},
        arr1=new char[8];
        int len=arr1.length,newnum=0,i=0;
        /*注意下面程序中for和while循环的不同
        for(int i=0;i<len;i++){
            if(num!=0){
                newnum=num&0xf;
                arr1[i]=arr[newnum];
                num>>>=4;
            }
        }
        */
        while(num!=0){
            newnum=num&15;
            arr1[i++]=arr[newnum];
            num>>>=4;
        }
        for(int j=len-1;j>=0;j--){
            if(arr1[j]==‘\u0000‘)
                continue;
            System.out.print(arr1[j]);
        }
    }
    //这个函数是从上面总结出来的,因为只需要修改一小部分内容,所有进制转换都可以通过该函数实现,
    public static void trans(int num,int base,int offset){
        char[] arr=new char[]{‘0‘,‘1‘,‘2‘,‘3‘,‘4‘,‘5‘,‘6‘,‘7‘,‘8‘,‘9‘,‘A‘,‘B‘,‘C‘,‘D‘,‘E‘,‘F‘},
        arr1=new char[8];
        int len=arr1.length,newnum=0,i=0;
        while(num!=0){
            newnum=num&base;
            arr1[i++]=arr[newnum];
            num>>>=offset;
        }
        for(int j=len-1;j>=0;j--){
            if(arr1[j]==‘\u0000‘)
                continue;
            System.out.print(arr1[j]);
        }
    }
    public static void toHex2(int num){
        trans(num, 15, 4);
    }
    public static void toBinary(int num){
        trans(num, 1, 1);
    }
    public static void toOctal(int num){
        trans(num, 7, 3);
    }
    
}