数组

　　数组是一种典型的顺序存储结构，他在内存中按照顺序存储的方式存储

• 数组的基本使用

　　　　数组创建的两种方法

　　　　　　1.int[] arr=new int[3];//3为数组的长度，int为数组的类型

　　　　　　2.int[] arr1=new int[]{1,3,5,6,8};//大括号中为数组的元素

　　　

public class TestArray {

    public static void main(String[] args) {
        //创建一个数组
        int[] arr1=new int[3];
        //获取数组的长度
        System.out.println("数组的长度："+arr1.length);
        //访问数组中的元素，数组名[下标] 注意下标从零开始，最大下标为数组的长度减一
        System.out.println("数组中的第零个元素："+arr1[0]);
        //为数组中的元素赋值
        arr1[0]=99;
        System.out.println(arr1[0]);
        arr1[1]=98;
        System.out.println(arr1[1]);
        arr1[2]=97;
        System.out.println(arr1[2]);
        //遍历数组
        for (int i = 0; i < arr1.length; i++) {
            System.out.println("数组中的第"+i+"个元素:"+arr1[i]);
        }
        //数组创建时为数组赋值
        int[] arr2= new int[] {1,2,3,4,5,6,7};
        System.out.println("数组二的长度："+arr2.length);

        System.out.println("快速查看数组中的元素："+Arrays.toString(arr2));

} }

public static void main(String[] args) {
        //解决数组的长度不可变
        int[] arr1= new int[] {9,8,7};
        int[] arr2=new int[arr1.length+1];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i]=arr1[i];
        }
        int t=4;
        arr2[arr2.length-1]=t;
        arr1=arr2;
        System.out.println(Arrays.toString(arr1));
    }

Arrays.toString(数组名)；//Arrays 的包是java.util.Arrays;

　　数组元素的删除

　　

public static void main(String[] args) {
        int[] arr1 = new int[] { 2, 4, 5, 6, 7 };
        System.out.println(Arrays.toString(arr1));
        int index = 2;
        // 删除5也就是数组中的第二个元素
        int[] tarray = new int[arr1.length - 1];
        for (int i = 0; i < tarray.length; i++) {
            if (i < index) {
                tarray[i] = arr1[i];
            } else if (i > index) {
                tarray[i] = arr1[i + 1];
            }
        }
        arr1 = tarray;
        System.out.println(Arrays.toString(arr1));

    }

 

 

• 面向对象的数组

　　　

package demo1.util;

import java.util.Arrays;

public class MyArray {
    // 用于存储数据的数组
    private Object[] elements;

    public MyArray() {
        elements = new Object[0];
    }

    // 获取数组的长度
    public int size() {
        return elements.length;
    }

    // 往数组的末尾添加一个元素
    public void add(Object obj) {
        Object[] newArray = new Object[elements.length + 1];
        for (int i = 0; i < elements.length; i++) {
            newArray[i] = elements[i];
        }
        newArray[elements.length] = obj;
        elements = newArray;
    }

    // 打印数组中的所有元素
    public void show() {
        System.out.println(Arrays.toString(elements));
    }

    // 删除数组中的元素
    public void delete(int index) {
        // 判断数组下标是否越界
        if (index < 0 || index >= elements.length) {
            throw new RuntimeException("数组下标越界");
        }
        // 创建一个比原数组长度小一的数组
        Object[] newArr = new Object[elements.length - 1];
        // 复制原有数据到新数组
        for (int i = 0; i < newArr.length; i++) {
            // 想要删除的元素后面的元素
            if (i < index) {
                newArr[i] = elements[i];
            } else {
                newArr[i] = elements[i + 1];
            }
        }
        // 替换旧数组
        elements = newArr;

    }

    public Object get(int index) {
        // 判断数组下标是否越界
        if (index < 0 || index >= elements.length) {
            throw new RuntimeException("数组下标越界");
        }
        return elements[index];
    }

    public void insert(Object obj, int index) {
        // 判断数组下标是否越界
        if (index < 0 || index >= elements.length) {
            throw new RuntimeException("数组下标越界");
        }
        // 创建一个比原数组长度大一的数组
        Object[] newArr = new Object[elements.length + 1];
        // 复制原有数据到新数组
        for (int i = 0; i < newArr.length; i++) {
            // 想要插入的元素前面面的元素
            if (i < index) {
                newArr[i] = elements[i];
            } else if (i == index) {
                newArr[i] = obj;
            } else {
                newArr[i] = elements[i - 1];
            }
        }
        // 替换旧数组
        elements = newArr;

    }

    // 设置指定位置的元素
    public void set(int index, Object obj) {

        // 判断数组下标是否越界
        if (index < 0 || index >= elements.length) {
            throw new RuntimeException("数组下标越界");
        }
        elements[index] = obj;
    }

    // 线性查找
    public int search(Object obj) {
        int index = -1;
        for (int j = 0; j < elements.length; j++) {
            if (elements[j].equals(obj)) {
                index = j;
                break;
            }
        }
        return index;
    }

    // 二分查找(只写了数字类型的，其他类型的需要写对应的比较方法，只要思路是这样我认为就是二分查找)
    public int binarySearch(Object obj) {
        int index = 0;
        try {
            int elemenet = Integer.parseInt(obj.toString());
            // 开始位置
            int startIndex = 0;
            // 结束位置
            int endIndex = elements.length - 1;
            index = -1;
            int i = 0;
            // 中间位置
            int mid = (startIndex + endIndex) / 2;
            // 循环查找
            while (true) {
                int midVal = Integer.parseInt(elements[mid].toString());
                // 如果找到了跳出循环
                if (midVal == elemenet) {
                    index = mid;
                    break;
                } else if(startIndex >= endIndex) {
                    break;
                } else if (midVal > elemenet) {// 若中间位置的元素比要查找的元素大，把结束位置设置为中间位置的前一个
                    endIndex = mid - 1;
                } else if (midVal < elemenet) {// 若中间位置的元素比要查找的元素小，把开始位置设置为中间位置的后一个
                    startIndex = mid + 1;
                }
                mid = (startIndex + endIndex) / 2;
                i++;
            }
        } catch (Exception e) {
            System.err.println("目前只写了整数类型的，其他的可以自己实现大小比较方法，包括日期，以及其他的各种Java对象");
        }
        return index;
    }
}

 

 

package demo1;

//二分查找法
public class TestBinarySearch {
    public static void main(String[] args) {
        // 目标数组
        int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        // 要查找的元素
        int elemenet = 9;
        // 开始位置
        int startIndex = 0;
        // 结束位置
        int endIndex = arr.length - 1;
//        int index =findElement(startIndex,endIndex);
        int index = -1;
        int i = 0;
        // 中间位置
        int mid = (startIndex + endIndex) / 2;
        // 循环查找
        while (true) {
            
            // 如果找到了跳出循环
            if (arr[mid] == elemenet) {
                index = mid;
                break;
            }else if (startIndex >= endIndex) {
                break;
            } else if (arr[mid] > elemenet) {// 若中间位置的元素比要查找的元素大，把结束位置设置为中间位置的前一个
                endIndex = mid - 1;
            } else if (arr[mid] < elemenet) {// 若中间位置的元素比要查找的元素小，把开始位置设置为中间位置的后一个
                startIndex = mid + 1;
            }
            mid = (startIndex + endIndex) / 2;
            i++;
        }
        if (index == -1) {
            System.out.println("没有要查找的元素");
        } else {
            System.out.println("第" + index + "个元素为" + arr[index]);
        }
    }
}

 

• 查找算法

　　　　线性查找（）

　　　　二分查找法（是一种在有序数组中查找某一特定元素的搜索算法）

　　　　找到有序数组的中间位置，看这个数组是不是要查找的元素，如果是则返回，如果不是，看要查找的数字比他大还是小，小的话查左边的数组，大的话查右边的数组。

　　　　

package demo1;

//二分查找法
public class TestBinarySearch {
    public static void main(String[] args) {
        // 目标数组
        int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        // 要查找的元素
        int elemenet = 9;
        // 开始位置
        int startIndex = 0;
        // 结束位置
        int endIndex = arr.length - 1;
//        int index =findElement(startIndex,endIndex);
        int index = -1;
        int i = 0;
        // 中间位置
        int mid = (startIndex + endIndex) / 2;
        // 循环查找
        while (true) {
            // 如果找到了跳出循环
            if (arr[mid] == elemenet) {
                index = mid;
                break;
            } else if (arr[mid] > elemenet) {// 若中间位置的元素比要查找的元素大，把结束位置设置为中间位置的前一个
                endIndex = mid - 1;
            } else if (arr[mid] < elemenet) {// 若中间位置的元素比要查找的元素小，把开始位置设置为中间位置的后一个
                startIndex = mid + 1;
            }
            mid = (startIndex + endIndex) / 2;
            i++;
        }
        if (index == -1) {
            System.out.println("没有要查找的元素");
        } else {
            System.out.println("第" + index + "个元素为" + arr[index]);
        }
    }
}

 

package demo1;

import demo1.util.MyArray;

public class TestMyArrayBinarySearch {
    public static void main(String[] args) {
        MyArray m= new MyArray();
        m.add(1);
        m.add(3);
        m.add(5);
        m.add(7);
        m.add(9);
        System.out.println(m.binarySearch(7));
    }
}

package demo1;

import demo1.util.MyArray;

public class TestMyArraySearch {
    public static void main(String[] args) {
        MyArray m = new MyArray();
        m.add(1);
        m.add("a");
        m.add(3);
        m.add(4);

        System.out.println(m.search("a"));
    }
}