javase

JavaSE/day05/src/main/java/com/sf/BinFind.java

@@ -0,0 +1,33 @@
+package com.sf;
+
+/**
+ * 二分查找
+ */
+public class BinFind {
+    public static void main(String[] args) {
+        //二分法查找：要求此数组必须是有序的。
+        int[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
+        boolean isFlag = true;
+        int value = 256;
+//int value = 25;
+        int head = 0;//首索引位置
+        int end = arr3.length - 1;//尾索引位置
+        while(head <= end){
+            int middle = (head + end) / 2;
+            if(arr3[middle] == value){
+                System.out.println("找到指定的元素，索引为：" + middle);
+                isFlag = false;
+                break;
+            }else if(arr3[middle] > value){
+                end = middle - 1;
+            }else{//arr3[middle] < value
+                head = middle + 1;
+            }
+        }
+
+        if(isFlag){
+            System.out.println("未找打指定的元素");
+        }
+
+    }
+}

JavaSE/day05/src/main/java/com/sf/Test1.java

@@ -1,14 +1,100 @@
 package com.sf;
 
+
+import javax.xml.transform.Source;
+import java.util.Arrays;
+
 public class Test1 {
     public static void main(String[] args) {
-        int[] aa = new int[5];
-        for (int i= 0 ;i <aa.length;i++){
-            aa[i] = i+1;
-            System.out.println("数组元素"+aa[i]);
-        }
-        System.out.println("========================================");
-        aa = null;
-        System.out.println(aa[2]);
+//        int[] aa = new int[5];
+//        for (int i= 0 ;i <aa.length;i++){
+//            aa[i] = i+1;
+//            System.out.println("数组元素"+aa[i]);
+//        }
+//        System.out.println("========================================");
+//        aa = null;
+//        System.out.println(aa[2]);
+/**
+ * 数组排序
+ */
+        int[] aa = {1,9,3,5,2,4,7,8};
+        Arrays.sort(aa,1,6);
+        System.out.println(Arrays.toString(aa));
+        /**
+         * 字符串排序
+         */
+        String[] str = {"zhangsan","lisi","gu"};
+        Arrays.sort(str);
+        System.out.println(Arrays.toString(str));
+
+        /**
+         * 二分查找
+         */
+        int[] bin = {1,2,3,4,5,6,7,8,9};
+        int i = Arrays.binarySearch(bin, 7);
+        System.out.println(i);
+
+        /**
+         * 数组的复制
+         */
+        int[] bin2 = {1,2,3,4,5,6,7,8,9};
+        int[] newBin2 = Arrays.copyOf(bin2, bin2.length);
+        System.out.println(Arrays.toString(newBin2));
+
+        int[] newBin3 = Arrays.copyOfRange(bin2, 0, 3);    //包左不包右
+        System.out.println(Arrays.toString(newBin3));
+
+        String[] str2 = {"zhangsan","lisi","gu"};
+        String[] newStr2 = Arrays.copyOf(str2, str2.length);
+        System.out.println(Arrays.toString(newStr2));
+
+        String[] newStr3 = Arrays.copyOfRange(str2, 0, 2);
+        System.out.println(Arrays.toString(newStr3));  //包左不包右
+
+        /**
+         *比较两个数组是否相等
+         */
+        int[] bin3 = {1,2,3,4,5,6,7,8,9};
+        int[] bin4 = {1,2,3,4,5,6,7,8,9};
+        int[] bin5 = {1,2,3,4,5};
+
+        boolean equals = Arrays.equals(bin3, bin4);
+        System.out.println("bin3==bin4======>"+equals);
+
+        boolean equals2 = Arrays.equals(bin3, bin5);
+        System.out.println("bin3==bin5=========>"+equals2);
+
+        /**
+         * 数组的填充
+         */
+        int[] cc = new int[5];
+        System.out.println(Arrays.toString(cc));
+
+        Arrays.fill(cc,5);
+        System.out.println(Arrays.toString(cc));
+        /**
+         * 用对象进行填充数组
+         */
+        String[] dd = new String[5];
+        System.out.println(Arrays.toString(dd));
+
+        Arrays.fill(dd,"这回不是null");
+        System.out.println(Arrays.toString(dd));
+
+
+        /**
+         * 将a数组[fromIndex,toIndex)部分填充为val值
+         */
+        int[] ff = new int[5];
+        System.out.println(Arrays.toString(ff));
+
+        Arrays.fill(ff,0,4,99); //包左不包右
+        System.out.println(Arrays.toString(ff));
+
+        String[] ee = new String[9];
+        System.out.println(Arrays.toString(ee));
+
+        Arrays.fill(ee,0,4,"非空啦");//包左不包右
+        System.out.println(Arrays.toString(ee));
     }
 }

JavaSE/day05/src/main/java/com/sf/Test19BubbleSort.java

@@ -0,0 +1,89 @@
+package com.sf;
+
+/*
+ 1、冒泡排序（最经典）
+思想：每一次比较“相邻（位置相邻）”元素，如果它们不符合目标顺序（例如：从小到大），
+     就交换它们，经过多轮比较，最终实现排序。
+	 （例如：从小到大）	 每一轮可以把最大的沉底，或最小的冒顶。
+
+过程：arr{6,9,2,9,1}  目标：从小到大
+
+第一轮：
+	第1次，arr[0]与arr[1]，6>9不成立，满足目标要求，不交换
+	第2次，arr[1]与arr[2]，9>2成立，不满足目标要求，交换arr[1]与arr[2] {6,2,9,9,1}
+	第3次，arr[2]与arr[3]，9>9不成立，满足目标要求，不交换
+	第4次，arr[3]与arr[4]，9>1成立，不满足目标要求，交换arr[3]与arr[4] {6,2,9,1,9}
+	第一轮所有元素{6,9,2,9,1}已经都参与了比较，结束。
+	第一轮的结果：第“一”最大值9沉底（本次是后面的9沉底），即到{6,2,9,1,9}元素的最右边
+
+第二轮：
+	第1次，arr[0]与arr[1]，6>2成立，不满足目标要求，交换arr[0]与arr[1] {2,6,9,1,9}
+	第2次，arr[1]与arr[2]，6>9不成立，满足目标要求，不交换
+	第3次：arr[2]与arr[3]，9>1成立，不满足目标要求，交换arr[2]与arr[3] {2,6,1,9,9}
+	第二轮未排序的所有元素 {6,2,9,1}已经都参与了比较，结束。
+	第二轮的结果：第“二”最大值9沉底（本次是前面的9沉底），即到{2,6,1,9}元素的最右边
+第三轮：
+	第1次，arr[0]与arr[1]，2>6不成立，满足目标要求，不交换
+	第2次，arr[1]与arr[2]，6>1成立，不满足目标要求，交换arr[1]与arr[2] {2,1,6,9,9}
+	第三轮未排序的所有元素{2,6,1}已经都参与了比较，结束。
+	第三轮的结果：第三最大值6沉底，即到 {2,1,6}元素的最右边
+第四轮：
+	第1次，arr[0]与arr[1]，2>1成立，不满足目标要求，交换arr[0]与arr[1] {1,2,6,9,9}
+	第四轮未排序的所有元素{2,1}已经都参与了比较，结束。
+	第四轮的结果：第四最大值2沉底，即到{1,2}元素的最右边
+*/
+public class Test19BubbleSort{
+    public static void main(String[] args){
+        int[] arr = {6,9,2,9,1};
+
+        //目标：从小到大
+        //冒泡排序的轮数 = 元素的总个数 - 1
+        //轮数是多轮，每一轮比较的次数是多次，需要用到双重循环，即循环嵌套
+        //外循环控制 轮数，内循环控制每一轮的比较次数和过程
+        for(int i=1; i<arr.length; i++){ //循环次数是arr.length-1次/轮
+			/*
+			假设arr.length=5
+			i=1,第1轮，比较4次
+				arr[0]与arr[1]
+				arr[1]与arr[2]
+				arr[2]与arr[3]
+				arr[3]与arr[4]
+
+				arr[j]与arr[j+1]，int j=0;j<4; j++
+
+			i=2,第2轮，比较3次
+				arr[0]与arr[1]
+				arr[1]与arr[2]
+				arr[2]与arr[3]
+
+				arr[j]与arr[j+1]，int j=0;j<3; j++
+
+			i=3,第3轮，比较2次
+				arr[0]与arr[1]
+				arr[1]与arr[2]
+
+				arr[j]与arr[j+1]，int j=0;j<2; j++
+			i=4,第4轮，比较1次
+				arr[0]与arr[1]
+
+				arr[j]与arr[j+1]，int j=0;j<1; j++
+
+				int j=0; j<arr.length-i; j++
+			*/
+            for(int j=0; j<arr.length-i; j++){
+                //希望的是arr[j] < arr[j+1]
+                if(arr[j] > arr[j+1]){
+                    //交换arr[j]与arr[j+1]
+                    int temp = arr[j];
+                    arr[j] = arr[j+1];
+                    arr[j+1] = temp;
+                }
+            }
+        }
+
+        //完成排序，遍历结果
+        for(int i=0; i<arr.length; i++){
+            System.out.print(arr[i]+"  ");
+        }
+    }
+}

JavaSE/day05/src/main/java/com/sf/Test19BubbleSort2.java

@@ -0,0 +1,34 @@
+package com.sf;
+
+/*
+思考：冒泡排序是否可以优化
+*/
+class Test19BubbleSort2{
+    public static void main(String[] args) {
+        int[] arr = {1, 3, 5, 7, 9};
+
+        //从小到大排序
+        for (int i = 0; i < arr.length - 1; i++) {
+            boolean flag = true;//假设数组已经是有序的
+            for (int j = 0; j < arr.length - 1 - i; j++) {
+                //希望的是arr[j] < arr[j+1]
+                if (arr[j] > arr[j + 1]) {
+                    //交换arr[j]与arr[j+1]
+                    int temp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = temp;
+
+                    flag = false;//如果元素发生了交换，那么说明数组还没有排好序
+                }
+            }
+            if (flag) {
+                break;
+            }
+        }
+
+        //完成排序，遍历结果
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i] + "  ");
+        }
+    }
+}

JavaSE/day05/src/main/java/com/sf/TestArrayOrderSearch.java

@@ -0,0 +1,26 @@
+package com.sf;
+
+/**
+ * 顺序查找
+ */
+public class TestArrayOrderSearch {
+    //查找value第一次在数组中出现的index
+    public static void main(String[] args){
+        int[] arr = {4,5,6,1,9};
+        int value = 1;
+        int index = -1;
+
+        for(int i=0; i<arr.length; i++){
+            if(arr[i] == value){
+                index = i;
+                break;
+            }
+        }
+
+        if(index==-1){
+            System.out.println(value + "不存在");
+        }else{
+            System.out.println(value + "的下标是" + index);
+        }
+    }
+}

JavaSE/day05/src/main/java/com/sf/TestArrayReverse1.java

@@ -0,0 +1,38 @@
+package com.sf;
+
+/**
+ * 数组的反转
+ */
+public class TestArrayReverse1 {
+    public static void main(String[] args) {
+        int[] arr = {1,2,3,4,5};
+        System.out.println("反转之前：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(arr[i]);
+        }
+
+        //反转
+         /*
+        思路：首尾对应位置的元素交换
+        （1）确定交换几次
+           次数 = 数组.length / 2
+        （2）谁和谁交换
+        for(int i=0; i<次数; i++){
+             int temp = arr[i];
+             arr[i] = arr[arr.length-1-i];
+             arr[arr.length-1-i] = temp;
+        }
+         */
+        for(int i=0; i<arr.length/2; i++){
+            int temp = arr[i];
+            arr[i] = arr[arr.length-1-i];
+            arr[arr.length-1-i] = temp;
+        }
+
+        System.out.println("反转之后：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(arr[i]);
+        }
+    }
+
+}

JavaSE/day05/src/main/java/com/sf/TestArrayReverse2.java

@@ -0,0 +1,25 @@
+package com.sf;
+
+public class TestArrayReverse2 {
+    public static void main(String[] args) {
+        int[] arr = {1,2,3,4,5};
+        System.out.println("反转之前：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(arr[i]);
+        }
+
+        //反转
+        //左右对称位置交换
+        for(int left=0,right=arr.length-1; left<right; left++,right--){
+            //首  与  尾交换
+            int temp = arr[left];
+            arr[left] = arr[right];
+            arr[right] = temp;
+        }
+
+        System.out.println("反转之后：");
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(arr[i]);
+        }
+    }
+}