zoukankan html css js c++ java

Java数组

Java数组

ArrayTest01——数组的一些概念

什么是数组？

字面意思是“一组数据”。

数组实际上是一个容器，可以同时容纳多个元素。（数组是多个数据的集合。）

Java语言中的数组是一种引用数据类型。不属于基本数据类型。数组的父类是Object。
数组存储什么样的数据？

数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。

java中的数组要求数组中元素的类型统一。比如int类型数组只能存储int类型，Person类型数组只能存储Person类型。
例如：超市购物，购物袋中只能装苹果，不能同时装苹果和橘子。（数组中存储的元素类型统一）
数组存储在哪个地方？

数组因为是引用类型，所以数组对象是堆内存当中。（数组是存储在堆当中的）

数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储java对象。
数组有哪些特点？

数组一旦创建，在java中规定，长度不可变。（数组长度不可变）

数组在内存方面存储的时候，数组中的元素内存地址(存储的每一个元素都是有规则的挨着排列的)是连续的。内存地址连续。

数组中首元素的内存地址作为整个数组对象的内存地址。

数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是：length - 1，下标非常重要，因为我们对数组中元素进行“存取”的时候，都需要通过下标来进行。

每个元素占用空间大小一样。
数组的分类？

数组的分类：一维数组、二维数组、三维数组、多维数组...（一维数组较多，二维数组偶尔使用！）
如何获得数组的长度？

所有的数组对象都有length属性(java自带的)，用来获取数组中元素的个数。
数组这种数据结构的优点是什么？

优点：查询/查找/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构。

为什么检索效率高？
第一：每一个元素的内存地址在空间存储上是连续的。
第二：每一个元素类型相同，所以占用空间大小一样。
第三：知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以
通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位
元素，所以数组的检索效率是最高的。

数组中存储100个元素，或者存储100万个元素，在元素查询/检索方面，效率是相同的，
因为数组中元素查找的时候不会一个一个找，是通过数学表达式计算出来的。（算出一个
内存地址，直接定位的。）
数组这种数据结构的缺点是什么？

第一：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低，因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。
第二：数组不能存储大数据量，为什么？
因为很难在内存空间上找到一块特别大的连续的内存空间。

注意：对于数组中最后一个元素的增删，是没有效率影响的。
怎么声明/定义一个一维数组？

int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;
怎么初始化一个一维数组呢？

包括两种方式：静态初始化一维数组，动态初始化一维数组。

静态初始化语法格式：int[] array = {100, 2100, 300, 55};

动态初始化语法格式：int[] array = new int[5]; // 初始化一个5个长度的int类型数组，每个元素默认值0

String[] names = new String[6]; // 初始化6个长度的String类型数组，每个元素默认值null。

public class ArrayTest01 {
    public static void main(String[] args) {
        // 声明一个int类型的数组，使用静态初始化的方式
        int[] a = {1, 100, 10, 20, 55, 689};
        // 这是C++风格，不建议java中使用。
        //int a[] = {1, 100, 10, 20, 55, 689};

        // 所有的数组对象都有length属性
        System.out.println("数组中元素的个数" + a.length);

        // 数组中每一个元素都有下标
        // 通过下标对数组中的元素进行存和取。
        // 取（读）
        System.out.println("第一个元素 = " + a[0]);
        System.out.println("最后一个元素 = " + a[5]);
        System.out.println("最后一个元素 = " + a[a.length - 1]);

        // 存（改）
        // 把第一个元素修改为111
        a[0] = 111;
        // 把最后一个元素修改为0
        a[a.length - 1] = 0;

        System.out.println("第一个元素 = " + a[0]);
        System.out.println("最后一个元素 = " + a[5]);

        // 一维数组怎么遍历呢？
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]); // i是从0到5，是下标
        }

        // 下标为6表示第7个元素，第7个元素没有，下标越界了。会出现什么异常呢？
        //System.out.println(a[6]); //ArrayIndexOutOfBoundsException（比较著名的异常。）

        // 从最后一个元素遍历到第1个元素
        for (int i = a.length - 1; i >= 0; i--) {
            System.out.println("颠倒顺序输出-->" + a[i]);
        }
    }
}

ArrayTest02——如何选择数组的初始化方式

Java每个类型的默认值?

数据类型默认值

byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0
boolean false
char u0000
引用数据类型 null
什么时候采用静态初始化方式，什么时候使用动态初始化方式呢？

当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式。
当你创建数组的时候，不确定将来数组中存储哪些数据，你可以采用动态初始化的方式，预先分配内存空间。

public class ArrayTest02 {
    public static void main(String[] args) {
        // 声明/定义一个数组，采用动态初始化的方式创建
        int[] a = new int[4]; // 创建长度为4的int数组，数组中每个元素的默认值是0
        // 后期赋值
        a[0] = 1;
        a[1] = 100;
        a[2] = 111;
        a[3] = 222; // 注意下标别越界。

        // 初始化一个Object类型的数组，采用动态初始化方式
        Object[] objs = new Object[3]; // 3个长度，动态初始化，所以每个元素默认值是null
        String[] strs = new String[3];

        // 采用静态初始化的方式
        String[] strs2 = {"abc", "def", "xyz"};

        // 存储Object，采用静态初始化呢？
      	Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = new Object();
        Object[] objects = {o1, o2, o3};
        Object[] objects = {new Object(), new Object(), new Object()};
    }
}

ArrayTest03——当一个方法上，参数的类型是一个数组的时候

有两个方法如下：

 public static void printArray(int[] array){
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }
    }

    public static void printArray(String[] args){
        for(int i = 0; i < args.length; i++){
            System.out.println("String数组中的元素：" + args[i]);
        }
    }

参数的类型是一个数组的时候，该如何传入参数？

方式1：

//int型数组
int[] x = {1,2,3,4};
printArray(x);
//String类型数组
String[] stringArray = {"abc", "def", "hehe", "haha"};
printArray(stringArray);

方式2：

printArray(new String[3]);	//3个null
priantArray(new int[4]);	//4个0

ArrayTest04——当一个方法的参数是一个数组的时候，我们还可以采用这种方式传

参数为数组的方法如下:

// 在为什么要使用静态方法？因为不需要new对象就可以调用该方法。
public static void printArray(int[] array){
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
}

传参数：

printArray(new int[]{1,2,3});

ArrayTest05——main方法上面的“String[] args”有什么用？

首先谁负责调用main方法？

JVM。
main方法上面的“String[] args”有什么用？

JVM调用main方法的时候，会自动传一个String数组过来。

JVM默认传递过来的这个数组对象的长度？默认是0。
这个数组什么时候里面会有值呢？

其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数自动会被转换为“String[] args”.

例如这样运行程序：java ArrayTest05 abc def xyz

那么这个时候JVM会自动将“abc def xyz”通过空格的方式进行分离，分离完成之后，自动放到“String[] args”数组当中。

所以main方法上面的String[] args数组主要是用来接收用户输入参数的。

把abc def xyz 转换成字符串数组：{"abc","def","xyz"}

public class ArrayTest05 {
    // 这个方法程序员负责写出来，JVM负责调用。JVM调用的时候一定会传一个String数组过来。
    public static void main(String[] args) {
        // JVM默认传递过来的这个数组对象的长度？默认0
        // 通过测试得出：args不是null。
        System.out.println("JVM给传递过来的String数组参数，它这个数组的长度是？" + args.length);

        // 以下这一行代码表示的含义：数组对象创建了，但是数组中没有任何数据。
        //String[] strs = new String[0];
        //String[] strs = {}; // 静态初始化数组，里面没东西。
        //printLength(strs);
    }

    public static void printLength(String[] args){
        System.out.println(args.length); // 0
    }
}

ArrayTest06——模拟一个系统，假设这个系统要使用，必须输入用户名和密码

package com.bjpowernode.javase.array;

/*
模拟一个系统，假设这个系统要使用，必须输入用户名和密码。
 */
public class ArrayTest06 {
    // 用户名和密码输入到String[] args数组当中。
    public static void main(String[] args) {
        if(args.length != 2){
            System.out.println("使用该系统时请输入程序参数，参数中包括用户名和密码信息，例如：zhangsan 123");
            return;
        }

        // 程序执行到此处说明用户确实提供了用户名和密码。
        // 接下来你应该判断用户名和密码是否正确。
        // 取出用户名
        String username = args[0];
        // 取出密码
        String password = args[1];

        // 假设用户名是admin，密码是123的时候表示登录成功。其它一律失败。
        // 判断两个字符串是否相等，需要使用equals方法。
        //if(username.equals("admin") && password.equals("123")){
        // 这样编写是不是可以避免空指针异常。
        // 采用以下编码风格，及时username和password都是null，也不会出现空指针异常。（这是老程序员给的一条编程经验。）
        if("admin".equals(username) && "123".equals(password)){
            System.out.println("登录成功，欢迎[" + username + "]回来");
            System.out.println("您可以继续使用该系统....");
        }else{
            System.out.println("验证失败，用户名不存在或者密码错误！");
        }
    }
}

ArrayTest07——深入理解数组中存储的类型为引用数据类型

一维数组的深入，数组中存储的类型为：引用数据类型。

对于数组来说，实际上只能存储java对象的“内存地址”。数组中存储的每个元素是“引用”。

public class ArrayTest07 {
    public static void main(String[] args) {
        // 创建一个Animal类型的数组
        Animal a1 = new Animal();
        Animal a2 = new Animal();
        Animal[] animals = {a1, a2};

        // 对Animal数组进行遍历
        for (int i = 0; i < animals.length; i++) {
            animals[i].move(); // 这个move()方法不是数组的。是数组当中Animal对象的move()方法。
        }

        // 动态初始化一个长度为2的Animal类型数组。
        Animal[] ans = new Animal[2];
        // 创建一个Animal对象，放到数组的第一个位置。
        ans[0] = new Animal();

        // Animal数组中可以存放Cat类型的数据，因为Cat是一个Animal。
        // Cat是Animal的子类。
        ans[1] = new Cat();

        // 创建一个Animal类型的数组，数组当中存储Cat和Bird
        Cat c = new Cat();
        Bird b = new Bird();
        Animal[] anis = {c, b};

        //Animal[] anis = {new Cat(), new Bird()}; // 该数组中存储了两个对象的内存地址。
        for (int i = 0; i < anis.length; i++){
            // 这个取出来的可能是Cat，也可能是Bird，不过肯定是一个Animal
            // 如果调用的方法是父类中存在的方法不需要向下转型。直接使用父类型引用调用即可。
            // 调用子对象特有方法的话，需要向下转型！！！
            if(anis[i] instanceof Cat){
                Cat cat = (Cat)anis[i];
                cat.catchMouse();
            }else if(anis[i] instanceof Bird){
                Bird bird = (Bird)anis[i];
                bird.sing();
            }
        }
    }
}

class Animal{
    public void move(){
        System.out.println("Animal move...");
    }
}

// 商品类
class Product{

}

// Cat是子类
class Cat extends Animal {
    public void move(){
        System.out.println("猫在走猫步！");
    }
    // 特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠！");
    }
}

// Bird子类
class Bird extends Animal {
    public void move(){
        System.out.println("Bird Fly!!!");
    }
    // 特有的方法
    public void sing(){
        System.out.println("鸟儿在歌唱！！！");
    }
}

ArrayTest08——一维数组的扩容

在java开发中，数组长度一旦确定不可变，那么数组满了怎么办？

java中对数组的扩容是：

先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。

结论：数组扩容效率较低。因为涉及到拷贝的问题。所以在以后的开发中请注意：尽可能少的进行数组的拷贝。

可以在创建数组对象的时候预估计以下多长合适，最好预估准确，这样可以减少数组的扩容次数。提高效率。

java中的数组是怎么进行拷贝的呢？

//System类的静态方法
static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
//参数
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。

示例：

public class ArrayTest08 {
    public static void main(String[] args) {
        // 拷贝源（从这个数组中拷贝）
        int[] src = {1, 11, 22, 3, 4};
        // 拷贝目标（拷贝到这个目标数组上）
        int[] dest = new int[20]; // 动态初始化一个长度为20的数组，每一个元素默认值0
        System.arraycopy(src, 0, dest, 0, src.length);

        // 数组中如果存储的元素是引用，可以拷贝吗？当然可以。
        String[] strs = {"hello", "world!", "study", "java", "oracle", "mysql", "jdbc"};
        String[] newStrs = new String[20];
        System.arraycopy(strs, 0, newStrs, 0, strs.length);
       
        System.out.println("================================");
        Object[] objs = {new Object(), new Object(), new Object()};
        Object[] newObjs = new Object[5];
        // 思考一下：这里拷贝的时候是拷贝对象，还是拷贝对象的地址。（地址。）
        System.arraycopy(objs, 0, newObjs, 0, objs.length);
        for (int i = 0; i < newObjs.length; i++) {
            System.out.println(newObjs[i]);
        }
    }
}

ArrayTest09——java中的二维数组

怎么理解二维数组？

二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。
三维数组是什么？

三维数组是一个特殊的二维数组，特殊在这个二维数组中每一个元素是一个一维数组。

际的开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。
二维数组静态初始化

int[][] array = {{1,1,1},{2,3,4,5},{0,0,0,0},{2,3,4,5},{2,3,4,5},{2,3,4,5},{2,3,4,5}};

示例：

public class ArrayTest09 {
    public static void main(String[] args) {
        // 一维数组
        int[] array = {100, 200, 300};
        System.out.println(array.length); // 3
        System.out.println("=======================");

        // 二维数组
        // 以下代码当中：里面的是4个一维数组。
        int[][] a = {
                {100, 200, 300},
                {30, 20, 40, 50, 60},
                {6, 7, 9, 1},
                {0}
        };
        System.out.println(a.length); // 4
        System.out.println(a[0].length); // 3
        System.out.println(a[1].length); // 5
        System.out.println(a[2].length); // 4
        System.out.println(a[3].length); // 1

        // 里面的是5个一维数组。
        int[][] a2 = {
                {100, 200, 300},
                {30, 20, 40, 50, 60},
                {6, 7, 9, 1},
                {0},
                {1,2,3,4,5}
        };
    }
}

ArrayTest10——二维数组中元素的读和改

如何表示二维数组中的一个一维数组中的元素？

a[二维数组中的一维数组的下标][一维数组的下标]

例如：

a[0][0]：表示第1个一维数组中的第1个元素。

a[3][100]：表示第4个一维数组中的第101个元素。

示例：

public class ArrayTest10 {
    public static void main(String[] args) {
        // 二维数组
        int[][] a = {
                {34,4,65},
                {100,200,3900,111},
                {0}
        };

        // 请取出以上的第1个一维数组。
        int[] 我是第1个一维数组 = a[0];
        int 我是第1个一维数组中的第1个元素 = 我是第1个一维数组[0];

        // 以下代码的由来是因为以上代码的合并导致的。
        System.out.println(a[0][0]);

        // 取出第2个一维数组当中第3个元素
        System.out.println("第二个一维数组中第三个元素：" + a[1][2]);

        // 取出第3个一维数组当中第1个元素
        System.out.println("第3个一维数组中第1个元素：" + a[2][0]);

        // 改
        a[2][0] = 11111;
        System.out.println(a[2][0]);

        // 注意别越界。
        //java.lang.ArrayIndexOutOfBoundsException
        //System.out.println(a[2][1]);
    }
}

ArrayTest11——二维数组的遍历

public class ArrayTest11 {
    public static void main(String[] args) {

        // 二维数组
        String[][] array = {
                {"java", "oracle", "c++", "python", "c#"},
                {"张三", "李四", "王五"},
                {"lucy", "jack", "rose"}
        };
        
        //遍历二维数组
        for(int i = 0; i < array.length; i++){ // 外层循环3次。（负责纵向。）
            for(int j = 0; j < array[i].length; j++){
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}

ArrayTest12——动态初始化二维数组

public class ArrayTest12 {
    public static void main(String[] args) {
        // 3行4列。
        // 3个一维数组，每一个一维数组当中4个元素。
        int[][] array = new int[3][4];

        // 静态初始化
        int[][] a = {{1,2,3,4},{4,5,6,76},{1,23,4}};
        printArray(a);

        // 没有这种语法
        //printArray({{1,2,3,4},{4,5,6,76},{1,23,4}});

        // 可以这样写。
        printArray(new int[][]{{1,2,3,4},{4,5,6,76},{1,23,4}});
    }

    public static void printArray(int[][] array){
        // 遍历二维数组。
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}

案例——使用一维数组模拟压栈弹栈操作

原理：

/**
 * @author: nie
 * @create: 2020-09-17 10:13
 * @description: 使用一维数组模拟压栈出栈操作
 **/
public class MyStack01 {
    //声明一个一位数组来存放栈中的元素
    private Object[] elements;

    //声明栈帧指向-1
    private int index = -1;

    //无参构造，默认初始化容量为10
    public MyStack01() {
        this.elements = new Object[10];
    }

    //有参构造，自定义栈的容量
    public MyStack01(int capacity) {
        this.elements = new Object[capacity];
    }

    public Object[] getElements() {
        return elements;
    }

    public void setElements(Object[] elements) {
        this.elements = elements;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    //压栈操作
    public void push(Object o) throws MyStackOperationException {
        //判断栈是否已满
        if (index == elements.length - 1) {
            //栈已满，抛出异常
            throw new MyStackOperationException("压栈失败，栈已满！");
        }
        //栈没有满，可以进行压栈操作
        elements[++index] = o;
        System.out.println("元素" + o + "压栈成功，当前栈帧指向位置--->" + index);
    }

    //出栈操作
    public void pop() throws MyStackOperationException {
        //判断指针指向
        if (index == -1) {
            //指向栈底，没有元素可以出栈
            throw new MyStackOperationException("栈中没有元素，弹栈失败！");
        }
        //栈中有元素，可以出栈
        //先将元素取出，然后指针再减1
        Object o = elements[index--];
        System.out.println("元素" + o + "出栈成功！当前指针指向-->" + index);
    }
}

测试代码：

测试1：压入10个元素进栈，刚好等于栈的初始化容量！

//压入10个元素
MyStack01 stack01 = new MyStack01();
for (int i = 0; i < 10; i++) {
    try {
        stack01.push(i + 1);
    } catch (MyStackOperationException e) {
        e.printStackTrace();
    }
}

测试2：压入11个元素进栈，大于栈中容量！

MyStack01 stack01 = new MyStack01();
for (int i = 0; i < 11; i++) {
    try {
        stack01.push(i + 1);
    } catch (MyStackOperationException e) {
        e.printStackTrace();
    }
}

测试3：压入10个元素进栈，出栈10个！

MyStack01 stack01 = new MyStack01();
//压栈10个
for (int i = 0; i < 10; i++) {
    try {
        stack01.push(i + 1);
    } catch (MyStackOperationException e) {
        e.printStackTrace();
    }
}
//出栈10个
for (int i = 0; i < 10; i++) {
    try {
        stack01.pop();
    } catch (MyStackOperationException e) {
        e.printStackTrace();
    }
}

测试3：压入10个元素进栈，出栈11个！

MyStack01 stack01 = new MyStack01();
//压栈10个
for (int i = 0; i < 10; i++) {
    try {
        stack01.push(i + 1);
    } catch (MyStackOperationException e) {
        e.printStackTrace();
    }
}
//出栈10个
for (int i = 0; i < 11; i++) {
    try {
        stack01.pop();
    } catch (MyStackOperationException e) {
        e.printStackTrace();
    }
}

BubbleSort——冒泡排序

/*
冒泡排序算法
    1、每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡。）
    2、核心：
        拿着左边的数字和右边的数字比对，当左边 > 右边的时候，交换位置。

原始数据：
3, 2, 7, 6, 8
第1次循环：(最大的跑到最右边。)
2, 3, 7, 6, 8 （3和2比较，2 < 3，所以2和3交换位置）
2, 3, 7, 6, 8 （虽然不需要交换位置：但是3和7还是需要比较一次。）
2, 3, 6, 7, 8 （7和6交换位置）
2, 3, 6, 7, 8 （虽然不需要交换位置：但是3和7还是需要比较一次。）

经过第1次循环，此时剩下参与比较的数据：2, 3, 6, 7
第2次循环：
2, 3, 6, 7 (2和3比较，不需要交换位置)
2, 3, 6, 7 （3和6比较，不需要交换位置）
2, 3, 6, 7 (6和7比较，不需要交换位置)

经过第2次循环，此时剩下参与比较的数据：2, 3, 6
第3次循环：
2, 3, 6 (2和3比较，不需要交换位置)
2, 3, 6 （3和6比较，不需要交换位置）

经过第3次循环，此时剩下参与比较的数据：2, 3
第4次循环：
2, 3 (2和3比较，不需要交换位置)

 */
public class BubbleSort {
    public static void main(String[] args) {

        // 这是int类型的数组对象
        //int[] arr = {3, 2, 7, 6, 8};
        int[] arr = {9, 8, 10, 7, 6, 0, 11};

        // 经过冒泡排序算法对以上数组中元素进行排序
        // 冒泡排序算法的核心是什么？

        // 7条数据，循环6次。以下的代码可以循环6次。
        /*
        for(int i = 0; i < arr.length-1; i++){
            System.out.println(i);
        }
         */

        // 7条数据，循环6次。以下的代码可以循环6次。（冒泡排序的外层循环采用这种方式）
        //int count = 0;
        int count2 = 0;
        for(int i = arr.length-1; i > 0; i--){
            for(int j = 0; j < i; j++){
                // 不管是否需要交换位置，总之是要比较一次的。
                //count++;
                if(arr[j] > arr[j+1]){
                    // 交换位置。
                    // arr[j] 和 arr[j+1] 交换
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    count2++;
                }
            }
        }

        //System.out.println("比较次数：" + count);
        System.out.println("交换位置的次数：" + count2); //13
        // 输出结果
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

SelectSort——选择排序

/*
选择排序：
    每一次从这堆“参与比较的数据当中”找出最小值，
    拿着这个最小值和“参与比较的这堆最前面的元素”交换位置。

    选择排序比冒泡排序好在：每一次的交换位置都是有意义的。

    关键点：选择排序中的关键在于，你怎么找出一堆数据中最小的。
        3 2 6 1 5
        假设：
            第一个3是最小的。
            3和2比较，发现2更小，所以此时最小的是2.

            继续拿着2往下比对，2和6比较，2仍然是最小的。
            继续拿着2往下比对，2和1比对，发现1更小，所以此时最小的是1.
            继续拿着1往下比对，1和5比对，发现1还是小的，所以1就是最小的。

            拿着1和最左边的3交换位置。
       2 6 3 5
       假设：
        第一个2是最小的。
        ...

      6 3 5
        假设6是最小的：
        6和3比对，发现3更小，所以此时最小的是3.
        ...
 */
public class SelectSort {
    public static void main(String[] args) {
        //要排序的数据
        int[] arr = {9, 8, 10, 7, 6, 0, 11};

        // 选择排序
        // 7条数据比较6次。（外层循环6次。）
        for(int i = 0; i < arr.length - 1; i++){
            // i的值是0 1 2 3 4 5 6
            // i正好是“参加比较的这堆数据中”最左边那个元素的下标。
            // i是一个参与比较的这堆数据中的起点下标。
            // 假设起点i下标位置上的元素是最小的。
            int min = i;
            for(int j = i+1; j < arr.length; j++){
                if(arr[j] < arr[min]){
                    min = j; //最小值的元素下标是j
                }
            }

            // 当i和min相等时，表示最初猜测是对的。
            // 当i和min不相等时，表示最初猜测是错的，有比这个元素更小的元素，
            // 需要拿着这个更小的元素和最左边的元素交换位置。
            if(min != i){
                // 表示存在更小的数据
                // arr[min] 最小的数据
                // arr[i] 最前面的数据
                int temp;
                temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }

        // 冒泡排序和选择排序实际上比较的次数没变。
        // 但选择交换位置的次数减少了。

        // 排序之后遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

//1 2 3 4 5
//假设1是最小的，结果1确实是最小的，就不需要交换位置。

BinarySearch——二分法查找

package com.bjpowernode.javase.array;

/*
1、数组工具类：自己写的。不是SUN的。

2、关于查找算法中的：二分法查找。
    10(下标0) 11 12 13 14 15 16 17 18 19 20(下标10)   arr数组。

    通过二分法查找，找出18这个元素的下标：
        (0 + 10) / 2 --> 中间元素的下标： 5

    拿着中间这个元素和目标要查找的元素进行对比：
        中间元素是：arr[5] --> 15
        15 < 18(被查找的元素)
        被查找的元素18在目前中间元素15的右边。
        所以开始元素的下标从0变成 5 + 1.

    再重新计算一个中间元素的下标：
        开始下标是：5 + 1
        结束下标是：10
        (6 + 10) / 2 --> 8

    8下标对应的元素arr[8]是18
        找到的中间元素正好和被找的的元素18相等，表示找到了：下标为8

    二分法查找的终止条件：一直折半，直到中间的那个元素恰好是被查找的元素。

3、二分法查找算法是基于排序的基础之上。（没有排序的数据是无法查找的。）

 */
public class ArrayUtil {
    public static void main(String[] args) {

        int[] arr = {100,200,230,235,600,1000,2000,9999};

        // 找出arr这个数组中200所在的下标。
        // 调用方法
        int index = binarySearch(arr, 230);
        System.out.println(index == -1 ? "该元素不存在！" : "该元素下标" + index);
    }

    /**
     * 从数组中查找目标元素的下标。
     * @param arr 被查找的数组（这个必须是已经排序的。）
     * @param dest 目标元素
     * @return -1表示该元素不存在，其它表示返回该元素的下标。
     */
    public static int binarySearch(int[] arr, int dest) {
        // 开始下标
        int begin = 0;
        // 结束下标
        int end = arr.length - 1;
        // 开始元素的下标只要在结束元素下标的左边，就有机会继续循环。
        while(begin <= end) {
            // 中间元素下标
            int mid = (begin + end) / 2;
            if (arr[mid] == dest) {
                return mid;
            } else if (arr[mid] < dest) {
                // 目标在“中间”的右边
                // 开始元素下标需要发生变化（开始元素的下标需要重新赋值）
                begin = mid + 1; // 一直增
            } else {
                // arr[mid] > dest
                // 目标在“中间”的左边
                // 修改结束元素的下标
                end = mid - 1; // 一直减
            }
        }
        return -1;
    }
}

查看全文

相关阅读:
Java如何实现跨平台
 什么是软件开发工具包（SDK）
什么是编程语言
 Java Hello World源代码notepad++版
 win10安装JDK
JDK安装与配置（Windows 7系统）
Eclipse安装与使用
 Eclipse Neon 汉化
 Eclipse Neon安装指导
 使用Sql语句快速将数据表转换成实体类

原文地址：https://www.cnblogs.com/nieaojie625/p/13681838.html