Java数据结构与算法之Array数组

目录:
1.数据概述
2.java数组的初始化
3.java数组API
4.数组排序
5.字符串转数组
6.数组封装后的使用

1. 数据概述

数组是重要的数据结构之一，以线性结构来存储固定数量大小,数据类型相同的数据

2. java数组的初始化

(1)声明和初始化分开

    public static void main(String[] args) {
        //(1)声明和初始化分开
        //申明 数组
        int a [];
        //申请空间
        a = new int[5];
        //根据下标赋值
        //默认值为0
        a[1] = 2;
        for (int i : a) {
            System.out.println(i);
        }

    }

(2)声明初始化同时进行

    public static void main(String[] args) {
        //(2)声明初始化同时进行
        int a  [] = new int[]{1,2,3,4};
        for (int i : a) {
            System.out.println(i);
        }

    }

3. java数组API

(1)java中数组类Arrays的继承关系

    java.lang.Object   
        java.util.Arrays 

(2)常用方法

asList(T... a) //将输入的参数转换成List类型的数据

binarySearch(Object[] a, Object key)//通过二分查找方法，在指定的数组中查找指定的元素，并返回下标

copyOf(Object[] original, int newLength) //将数组复制到另外一个数组中

copyOfRange(Object[] original, int from, int to) //将给定数组的给定区间元素复制到新数组中

equals(Object[] a, Object[] a2) //判断两个数组是否相等，也就是长度和元素值是否一致

deepEquals(Object[] a1, Object[] a2) //常用来比较多维数组

fill(Object[] a, Object val) //将指定的基本数据类型值分配到指定基本类型数组的每一项

fill(Object[] a, int fromIndex, int toIndex, Object val) //指定分配到指定的区间

sort(Object[] a)//增序排列

sort(Object[] a, int fromIndex, int toIndex) //指定需要排序的数组区间

toString(Object[] a) //转换成字符串类型

4. 数组排序

java中对数组的排序有两种方法，第一种是直接使用API中的sort(Object[] a)方法进行排序或者采用算法中的
各类算法，比如：冒泡排序，选择排序，插入排序，归并排序等等。

5. 字符串转数组

(1)字符串转char[]

str="hello";  
char [] charArray = str.toCharArray(); 

(2)字符串转int[]

 public static void StringToArray(String str){  
        char[] ch;  
        int [] i;  
        int len;  
        //string长度  
        len = str.trim().length();  
        //初始化int数组  
        i=new int[len];  
        //通过charAt()取得单个字符转换成String类型再通过parseInt()转换成int类型  
        for (int j = 0; j < len; j++) {  
            i[j] =Integer.parseInt(String.valueOf(str.charAt(j)));  
        }         
        //int数组输出  
        System.out.println("int数组输出：");  
        for (int j = 0; j < i.length; j++) {  
            System.out.print(i[j]+"\t");  
        }  

    }  

6. 数组封装后的使用

public class UseArray {  
    private int[] array;  
    private int number = 0;  
    public UseArray(int max){  
        array = new int[max];  
    }  
    public void insert(int value){  
        array[number] = value;  
        number++;  
    }  
    public int find(int value){  
        for (int i= 0; i < number; i++) {  
            if(array[i]==value)  
                return i;  
        }  
        return number;  
    }  

    public boolean delete(int value){  
        int index = find(value);  
        if(index != number){  
            for (int i = index; i < number-1; i++) {  
                array[i] = array[i+1];  
            }  
            number--;  
            return true;  
        }  
        return false;  
    }  

    public void display(){  
        for (int i = 0; i < number; i++) {  
            System.out.printf(array[i]+" ");  
        }  
    }  
    public static void main(String[] args) {  
        UseArray ua  = new UseArray(5);  
        ua.insert(1);  
        ua.insert(2);  
        ua.insert(6);  
        ua.insert(7);  
        ua.insert(3);  

        ua.display();  
        if(ua.find(5) != ua.number){  
            System.out.println("find,the number index is "+ua.find(5));  
        }else{  
            System.out.println("not found!");  
        }  
        if(ua.delete(5)!=true){  
            System.out.println("can not delete!");  
        }  
        ua.display();  
    }  
}  

优化查找(二分查找)

    private static int find(int[] array, int value) {
        int start = 0;
        int end = array.length-1;
        while(start <= end){
            int mid = (end + start) / 2;
            int midValue = array[mid];
            if (midValue < value)
                start = mid + 1 ;
            else if (midValue > value)
                end = mid -1;
            else
                return mid;

        }
        return -1;
    }