数组的一些知识点和插入选择冒泡排序

package test.sghuzu;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Test1 {
    /**
     Java中的内存分配
     Java程序在运行时，需要在内存中分配空间。
     为了提高效率，对每一片空间都进行了划分，因为每一片1区域都有特定的处理数据方式和内存管理方式
    
         栈  存储局部变量
         堆  存储new出来的东西
         方法区  暂时不管
         本地方法区  系统有关，不管
         寄存器  给CPU使用，也不管
         
             局部变量，在方法中定义或者方法中声明的变量都是局部变量
         
         
             栈内存的特点：
                 每一个new出来的东西都有地址值
                 每一个变量都有默认值
                     byte,short,int,long 0
                     float,double 0.0
                     char 'u0000'
                     boolean false
                 使用完毕就变成了垃圾，但是并没有立即回收。会在垃圾回收器空闲的时候回收
                 栈内存中的值数据用完就释放掉。
     */
    
    /*
          数组声明：
              数据类型[] 数组名;
              数据类型   数组名[];
              两种方式效果一样，读法不同，第一个叫做一个名为数组名的数据类型数组，第二种叫做一个数据类型的 数组变量数组名。第二种更早，现在一般用第一种
              
          数组的初始化：
              两种初始化方式的区别在于数组的长度。第一种是自己固定数组长度，初始值由系统的默认值填充；第二种是自己固定数组的值，数组的长度由系统根据数组的值确定
              动态初始化：
                  例子： int[] arr=new int[3];
              静态初始化：
                  例子：int[] arr=new int[]{1,2,3};
                  上面这种形式不常用了，我们一般喜欢使用它的简写形式：
                       int[] arr={1,2,3};
                      
          值得注意的是：静态初始化数组实际上也是new声明的，不过是在声明赋了初始默认值后使用你给的值替代原来的默认值。和一些数组长度的不同控制
          
          数组的遍历，数组中的元素使用下标来指定并做一系列操作。数组名.length得到数组的长度。
      
     */
    
    /*
     * 求最值：
     以求最大值为例，选出一个数组中的值为参照物，依次使用其他的数组元素和它进行比较，比它大的取代它和剩下的元素进行比较，剩下的就是最大的元素了
    */
    /*
     逆序：
     新建一个类型和长度都和原数组相同的数组，for循环依次输出原数组的元素，并将元素赋值给新数组位置为数组长度-旧数组现在下标位置的元素
     */
    /*
     数组中元素从大到小排序
     */
    public static void main(String[] args){
        int[] arr=new int[]{43,12,46,23,45,12,98};
        
        /*int[] arr1=rebackArr(arr);
        iteratorArrForEach(arr);
        System.out.println();
        iteratorArr(arr1);*/
        
        /*int[] arr1=SortMaxToMin(arr);    
        iteratorArrForEach(arr);
        System.out.println();
        iteratorArr(arr1);*/
        iteratorArrForEach(arr);
        
        //SortMaxToMin3(arr);
        System.out.println();
        iteratorArrForEach(arr);
        
    }
    
    public static void iteratorArr(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static void iteratorArrForEach(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
    
    public static int getMax(int[] arr){
        int max=arr[0];
        
        for(int i=1;i<arr.length;i++){
            if(arr[i]>arr[i-1]){
                max=arr[i];
            }
        }
        return max;
    }
    
    public static int getMin(int[] arr){
        int min=arr[0];
        
        for(int i=1;i<arr.length;i++){
            if(arr[i]<arr[i-1]){
                min=arr[i];
            }
        }
        return min;
    }
    
    public static int[] rebackArr(int[] arr){
        int[] arr1=new int[arr.length];
        for(int i=0,j=arr.length-1;i<arr.length;i++,j--){
            arr1[i]=arr[j];
        }
        return arr1;    
    }
    
    public static  int[] SortMaxToMin(int[] arr){
        /**
         * 利用的是前面求最值的思路，应该是选择排序吧！
         *
         */
        /**
         * 一般进行数组的排序都将改变原来数组的位置。因为数组是引用数据类型，针对同一个堆内存地址的改变。所以需要将原来数组的元素全部放入另一个数组之内
         * ，操作另一个数组进行排序才会不改变原来数组。注意，新数组不能是调用原数组的引用
         */
        int[] arr1=Arrays.copyOf(arr, arr.length);
        //iteratorArr(arr1);
        //int[] arr1=new int[arr.length];
        /*for(int i=0;i<arr.length;i++){
            arr1[i]=arr[i];
        }*/
        for(int j=0;j<arr1.length;j++){
            for(int i=j+1;i<arr1.length;i++){                
                if(arr1[i]>arr1[j]){
                    arr1[j]=arr1[j]^arr1[i];    
                    arr1[i]=arr1[j]^arr1[i];
                    arr1[j]=arr1[j]^arr1[i];                    
                }
            }
            
        }
        return arr1;
    }
    public static   int[] SortMaxToMin1(int[] arr){
        /**
         * 选择排序，第一个开始，元素与它右边的元素比较，大的向右跑，一轮下来，最大的数就是最后面的
         * 接下来就是循环了，依旧进行一样的循环
         *
         for(int i=0;i<arr.length;i++){
            for(int j=1;j<arr.length;j++){
                if(arr[j]>arr[j-1]){
                    arr[j]=arr[j]+arr[j-1]-(arr[j-1]=arr[j]);
                    
                }            
            }
        }
        
        这样可以达到排序的效果，但有心你就可以发现，第一轮已经确定最后一个是最大的了，第二轮还进行判断的话就代码多余了，所以我们进行优化，每一轮比较的次数比上一轮少1
        所以语法应该是这样的：
        for(int i=0;i<arr.length;i++){
            for(int j=1;j<arr.length-i;j++){
                if(arr[j]>arr[j-1]){
                    arr[j]=arr[j]+arr[j-1]-(arr[j-1]=arr[j]);
                    
                }            
            }
        }
         */
        for(int i=0;i<arr.length;i++){
            for(int j=1;j<arr.length-i;j++){
                if(arr[j]>arr[j-1]){
                    arr[j]=arr[j]+arr[j-1]-(arr[j-1]=arr[j]);
                    
                }            
            }
        }
        
        return arr;
    }
    
  package test.sghuzu;

public class Test8 {//我的插入排序
    public static void main(String[] args){
        int arr[]={12,32,76,23,97,12,32,4};
        for(int j=0;j<arr.length-1;j++){
            for(int i=0;i<arr.length;i++){
                if(arr[j]>arr[i]){
                    int temp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=temp;
                    break;
                }
            }
        }
        for(int s:arr){
            System.out.print(s+" ");
        }
        
    }

}


    
    
    
    /* 一些源码 */
    //非基本类型  
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {  
            T[] copy = ((Object)newType == (Object)Object[].class)  
                ? (T[]) new Object[newLength]  
                : (T[]) Array.newInstance(newType.getComponentType(), newLength);  
            System.arraycopy(original, 0, copy, 0,  
                             Math.min(original.length, newLength));  
            return copy;  
        }  
    //基本数据类型  
    public static int[] copyOf(int[] original, int newLength) {  
            int[] copy = new int[newLength];  
            System.arraycopy(original, 0, copy, 0,  
                             Math.min(original.length, newLength));  
            return copy;  
        }  

关于数组的声明和赋值：

public class Test {
    public static void main(String[] args){
        int[] i;
        i=new int[]{1,2,3};
        int[] j;
        i=new int[3];
        /**
         int[] k;
         k={1,2,3};        
         
         先声明，后赋值，本来是没有错的，但是int[] a={1,2,3};是一种简写形式，拆分了会报错。
         Java中{}代表的而是代码块的意思，如果k={1,2,3};相当于将一个{1,2,3}的代码块赋值给数组，所以报错
         */
        
    }

}

数组的逆序：

package test.sghuzu;

public class Test3 {
    public static void main(String[] args){
        int[] arr=new int[]{12,33,67,98,34,12,43,65,78};
        /**
         * 逆序
         */
        reversed(arr);
        System.out.println();
        reversed2(arr);
        
    }
    
    public static void reversed(int[] arr){
        for(int a:arr){
            System.out.print(a+"	");
        }
        System.out.println();
        int length=arr.length;
        for(int i=0;i<length/2;i++){//换length/2次
            arr[i]=arr[i]^arr[length-i-1];
            arr[length-1-i]=arr[i]^arr[length-1-i];
            arr[i]=arr[i]^arr[length-1-i];
            
        }
        for(int a:arr){
            System.out.print(a+"	");
        }
    }
    
    public static void reversed2(int[] arr){
        for(int a:arr){
            System.out.print(a+"	");
        }
        System.out.println();
        for(int i=0,j=arr.length-1;i<=j;i++,j--){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;    
            
            
        }
        for(int a:arr){
            System.out.print(a+"	");
        }
    }
    

}

寻找数组元素：

package test.sghuzu;

import java.util.Scanner;

public class Test4 {
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        String a[]={"星期一","星期二","星期三","星期四","星期五","星期六","星期天","星期一","星期三"};
        System.out.println("查找指定星期第一次出现的下标，-1表示不存在指定星期！");
        System.out.println("请输入查找的第一次出现的星期：");
        while(true){
            try{
                String s=input.next();
                int x=findFirstIndex(a,s);
                System.out.println(x);
                break;
            }catch(Exception e){
                System.out.println("输入异常，请重新输入！");
            }
        }
        
        
    }
    public static int findFirstIndex(String[] arr,String content){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==content||arr[i].equals(content)){
                return i;
            }
        }
        
        return -1;
        
    }
    public static int findFirstIndex2(String[] arr,String content){
        int index=-1;
        for(int i=0;i<arr.length;i++){
            if(arr[i]==content||arr[i].equals(content)){
                index=i;
                break;
            }
        }
        
        return index;
        
    }

}

    
    

}