4、数组

1、创建数组

　　• 数组是相同类型数据的有序集合.相同类型的若干个数据,按照一定先后次序排列组合而成。其中,每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们.
　　• 数组特点:其长度是确定的。数组一旦被创建，它的大小就是不可以改变的； 其元素必须是相同类型,不允许出现混合类型；数组中的元素可以是任何数据类型，包括基本类型和引用类型。

• 一维数组声明：　type[] arr_name;　type arr_name[];   Java中使用关键字new 创建数组对象

public class Test{
public static void main(String args[]){
int[] s = null;
s = new int[10];
for ( int i=0; i<10; i++ ) {
s[i] =2*i+1;
System.out.println(s[i]);
}
}
}

• 引用数组生成：

import java.lang.reflect.Array;

public class BallGame {

    public static void main(String[] args) {
        User[] ints = new User[10];
        User user1 = new User(10,"13453");
        User user2 = new User(100,"xiaoming");
        ints[0] =  user1;
        ints[1] =  user2;
        System.out.println(ints[0].age);
    }
}

class User{
    int age ;
    String name;
    public User(int age,String name){
        this.age = age;
        this.name = name;
    }

}

2、数组初始化

• 静态初始化--->定义的时候直接赋值

public class BallGame {

    public static void main(String[] args) {
        //定义数组
        int[] ints = {1,2,3,4};
        for(int i=0;i<ints.length;i++){
            System.out.println(ints[i]);
        }
    }
}

• 动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。

public class BallGame {

    public static void main(String[] args) {
        //定义数组
        int[] ints = new int[2];
        ints[0] = 0;
        ints[1] = 1;
        for(int i=0;i<ints.length;i++){
            System.out.println(ints[i]);
        }
    }
}

• 默认初始化-->和成员变量默认赋值一样

3、数组的拷贝

package cn.sxt.array2;

/**
 * 测试数组的拷贝
 * @author Administrator
 *
 */
public class TestArrayCopy {
    public static void main(String[] args) {
//        testBasicCopy2();
        
        String[] str = {"阿里","京东","尚学堂","百度","亚马逊"};
        
//        removeElment(str, 1);
    
        
        str = extendRange(str);
        
    }
    
    //数组拷贝
    public static void  testBasicCopy(){
        String[]  s1 = {"aa","bb","cc","dd","ee"};
        String[]  s2 = new String[10];
        System.arraycopy(s1, 2, s2, 6, 3);
        
        for(int i=0;i<s2.length;i++) {
            System.out.println(i+"--"+s2[i]);
        }
    }
    
    //测试从数组中删除某个元素(本质上还是数组的拷贝)
    public static void  testBasicCopy2(){
        String[]  s1 = {"aa","bb","cc","dd","ee"};
    //    String[]  s2 = new String[5];
        
        System.arraycopy(s1, 3, s1, 3-1, s1.length-3);
        
        s1[s1.length-1] = null;
        
        for(int i=0;i<s1.length;i++) {
            System.out.println(i+"--"+s1[i]);
        }
        
    }
    
    //删除数组中指定索引位置的元素，并将原数组返回
    public static String[]  removeElment(String[]  s, int index){
        System.arraycopy(s, index+1, s, index, s.length-index-1);
        s[s.length-1] = null;
        for(int i=0;i<s.length;i++) {
            System.out.println(i+"--"+s[i]);
        }
        return s;
    }
    
    
    //数组的扩容（本质上是：先定义一个更大的数组，然后将原数组内容原封不动拷贝到新数组中）
    public  static  String[]   extendRange(String[] s1){
//        String[]   s1 = {"aa","bb","cc"};
        
        String[]  s2 = new  String[s1.length+10];
        
        System.arraycopy(s1, 0, s2, 0, s1.length);   //就将s1中所有的元素拷贝到了s2
        
        for(String temp:s2){
            System.out.println(temp);
        }
        return  s2;
    }
    
    
    
    
    
}

4、array工具

package cn.sxt.array2;

import java.util.Arrays;

/**
 * 测试java.util.Arrays工具类的使用
 * @author Administrator
 *
 */
public class TestArrays {
    public static void main(String[] args) {
        
        int[]  a = {100,20,30,5,150,80,200};
        
        System.out.println(a);
        
        //打印字符串
        System.out.println(Arrays.toString(a));  
        //排序
        Arrays.sort(a); 
        System.out.println(Arrays.toString(a));  
        
        //二分法查找
        System.out.println(Arrays.binarySearch(a, 30));
        
        
        
    }
}

5、多维数组

 

• 二维数组

package cn.sxt.array2;

/**
 * 测试二维数组
 * @author Administrator
 *
 */
public class Test2DimensionArray {
    
    public static void main(String[] args) {
//        int[]  a = new int[3];
//        Car[]  cars = new Car[3];
        
        int[][]  a = new  int[3][];
        
        a[0] = new int[]{20,30};
        a[1] = new int[]{10,15,80};
        a[2] = new int[]{50,60};
        
        System.out.println(a[1][2]);  

        
        //静态初始化二维数组
        int[][]  b = {
                {20,30,40},
                {50,20},
                {100,200,300,400}
        };
        
        System.out.println(b[2][3]);
        
        
    }
    
    
}


class Car{
    
}

• 实例

package cn.sxt.array2;

import java.util.Arrays;

/**
 * 测试数组存储表格数据
 * @author Administrator
 *
 */
public class TestArrayTableData {
    public static void main(String[] args) {
        Object[]  emp1 = {1001,"sfs",18,"讲师","2006.6.6"};
        Object[]  emp2 = {1002,"sffs",19,"程序员","2016.6.6"};
        Object[]  emp3 = {1003,"sfsdfs",22,"销售","2026.6.6"};
        
        Object[][] tableData = new Object[3][];
        tableData[0] = emp1;
        tableData[1] = emp2;
        tableData[2] = emp3;
        
        for(Object[] temp: tableData){
            System.out.println(Arrays.toString(temp));
        }
        
        
    }
}

 6、冒泡排序

package cn.sxt.array2;

import java.util.Arrays;

/**
 * 测试冒泡排序以及优化。
 * @author Administrator
 *
 */
public class TestBubbleSort {
    public static void main(String[] args) {
        
         int[] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
         int  temp = 0 ;
         for(int i=0;i<values.length-1;i++){
             boolean  flag = true;
             for(int  j=0; j<values.length-1-i; j++){
                 //比较大小，换顺序
                 if(values[j]>values[j+1]){
                     temp = values[j];
                     values[j] = values[j+1];
                     values[j+1] = temp;
                     
                     flag = false;
                 }
                 System.out.println(Arrays.toString(values));
             }
             if(flag){
                 System.out.println("结束！！！");
                 break;
             }
             System.out.println("#########");
             
         }
         
        
        
        
    }
}

7、二分法查找

package cn.sxt.array2;

import java.util.Arrays;

/**
 * 
 * @author Administrator
 *
 */
public class TestBinarySearch {
    public static void main(String[] args) {
         int[] arr = { 30,20,50,10,80,9,7,12,100,40,8};
         Arrays.sort(arr);

         System.out.println(Arrays.toString(arr));
         System.out.println(myBinarySearch(arr, 7));
         
    }
    
    public static  int  myBinarySearch(int[] arr, int value){
        int low = 0;
         int high = arr.length-1; 
         
         while(low<=high){
             int  mid = (low+high)/2;
             
             if(value==arr[mid]){
                     return mid;
             }
             
             if(value>arr[mid]){
                 low = mid+1;
             }
             
             if(value<arr[mid]){
                 high = mid-1;
             }
             
         }
         
         return  -1;
    }
    
    
}