Java学习日记基础篇（七) —— 数组、排序

数组

为什么要有数组？

案例：一个养鸡场有六只鸡，他们的体重分别为3kg，5kg，1kg，3.4kg，2kg，50kg。请问这六只鸡的总体重和平均体重是多少？

public class test5 
{
    public static void main(String[] args) 
    {
        //如果没有数组就要定义六个变量,然后算出结果,太麻烦了
        //现在我们定义一个可以存放6个float类型的数组
        float arr[] = new float[6]; 
        //给数组的各个元素赋值
        arr[0] = 3;        //3是低精度会自动转成高精度的float类型
        arr[1] = 5;
        arr[2] = 1;
        arr[3] = 3.4f;    //java中默认小数是double的所以在后面加上f说明是float类型,避
        arr[4] = 2;
        arr[5] = 50;
        
        float all = 0;
        for(int i=0;i<6;i++)        //遍历数组
        {
            all += arr[i];
        }
        System.out.println("总体中是" + all);
    }
}

数组可以存放多个同一类型的数据

数组的语法

//数组的定义1 —— 正常方法
    数据类型  数组名[ ]  =  new 数据类型[ 大小 ];
    int  a[ ]  =  new int[ 10 ];

//数组的定义2 —— 没事找事法
    //第一步:先声明数组
    数据类型  数组名[ ];       或者        数据类型[ ]  数组名;
    int  a[ ];    或   int[ ]  a;

    //第二步创建数组
    数组名  =  new  数据类型[ 大小 ];
    a = new  int[ 10 ];

//数组的定义3 —— 古板用法
    //在定义的时候直接初始化数组,大小有后面给的数的个数决定的
    数据类型  数组名[]  =  { 元素值, 元素值, ... }
    int  a[]  = { 2,5,6,7,8,9 }

//数组的引用
数组名[ 下标 ]

　　

public class test5 
{
    public static void main(String[] args) 
    {    
        float arr[] = {1.2f,2,3,4,5,7.8f};
        float all = 0;

        for(int i=1;i<arr.length;i++)       //可以用length来获取数组的长度 
        {
            all += arr[i];
        }
        System.out.println("平均时间: "+(all/arr.length));
    }
}

数组越界的报错

java.lang.ArrayIndexOutOfBoundsException

如何知道数组的大小

System.out.println(arr.length);

//这个length是这个数组的成员属性

对象数组　　

案例：一个养狗场有4只狗，分别是：

名字	体重
花花	4.5kg
白白	5.6kg
黑黑	7.8kg
红红	9.0kg

请编写一个程序，计算他们的平均体重，可以找出体重最大和最小的狗的名字，可以通过输入狗的名字，查找他们的体重

public class test6 
{
    public static void main(String[] args) 
    {
        //定义一个可以存放四只狗的对象数组
        Dog dogs[] = new Dog[4];
        
        //给每只狗赋值
        dogs[0].setName("花花");
        dogs[0].setWeight(4.5f);

    }

}
class Dog
{
    private String name;
    public float weight;
    public float getWeight() {
        return weight;
    }
    public void setWeight(float weight) {
        this.weight = weight;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}


报错：空指针异常
java.lang.NullPointerException

　　Java中没有指针，但引用的实质就是一个指针，引用里面存放的并不是对象而是该对象的地址，使得该引用指向了对象那个。而“=”在JAVA中并不该被翻译成赋值语句，因为他执行的是传递至的过程。

public class test6 
{
    public static void main(String[] args) 
    {
        //定义一个可以存放四只狗的对象数组
        Dog dogs[] = new Dog[4];    //仅仅创建了四个引用
        
        //给每只狗赋值
        dogs[0] = new Dog();        //创建Dog()对象,然后传递给dogs[0]引用
        dogs[0].setName("花花");
        dogs[0].setWeight(4.5f);
    }

}
class Dog
{
    private String name;
    public float weight;
    public float getWeight() {
        return weight;
    }
    public void setWeight(float weight) {
        this.weight = weight;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

import java.io.*;

public class test6 
{
    public static void main(String[] args) throws Exception
    {
        //定义一个可以存放四只狗的对象数组
        Dog dogs[] = new Dog[4];    //仅仅创建了四个引用
        //从控制台输入各个狗的信息
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br= new BufferedReader(isr);
        for(int i=0 ; i<4 ; i++)
        {
            dogs[i] = new Dog();
            System.out.println("请输入狗的名子");
            //从控制台读取狗名
            String name = br.readLine();    //之后会讲异常
            //讲名字赋值给对象
            dogs[i].setName(name);
            System.out.println("请输入狗的体重");
            String s_weight = br.readLine();
            float weight = Float.parseFloat(s_weight);//String->float
            //讲名字赋值给对象
            dogs[i].setWeight(weight);
        }
        //计算总体重
        float allWeight = 0;
        for(int i=0;i<4;i++)
        {
            allWeight+=dogs[i].getWeight();
        }
        //计算平均体重
        float avgWeight = allWeight/dogs.length;
        System.out.println("总体重="+allWeight+"平均体重"+avgWeight);
    }

}
class Dog
{
    private String name;
    public float weight;
    public float getWeight() {
        return weight;
    }
    public void setWeight(float weight) {
        this.weight = weight;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

找出体重最大的狗，且输入狗的名字，返回体重

import java.io.*;

public class test6 
{
    public static void main(String[] args) throws Exception
    {
        //定义一个可以存放四只狗的对象数组
        Dog dogs[] = new Dog[4];    //仅仅创建了四个引用
        //从控制台输入各个狗的信息
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br= new BufferedReader(isr);
        for(int i=0 ; i<4 ; i++)
        {
            dogs[i] = new Dog();
            System.out.println("请输入狗的名子");
            //从控制台读取狗名
            String name = br.readLine();    //之后会讲异常
            //讲名字赋值给对象
            dogs[i].setName(name);
            System.out.println("请输入狗的体重");
            String s_weight = br.readLine();
            float weight = Float.parseFloat(s_weight);//String->float
            //讲名字赋值给对象
            dogs[i].setWeight(weight);
        }
        //计算总体重
        float allWeight = 0;
        for(int i=0;i<4;i++)
        {
            allWeight+=dogs[i].getWeight();
        }
        //计算平均体重
        float avgWeight = allWeight/dogs.length;
        System.out.println("总体重="+allWeight+"平均体重"+avgWeight);
        
        //找出最大体重的狗
        //假设第一只狗体重最大
        float maxWeight = dogs[0].getWeight();
        int maxIndex=0;
        //按顺序和后面的狗比较
        for(int i=1;i<dogs.length;i++)
        {
            if(maxWeight<dogs[i].getWeight())
            {
                //修改
                maxWeight=dogs[i].getWeight();
                maxIndex=i;
            }
        }
        System.out.println("体重最大的狗是第"+(maxIndex+1)+"体重是"+dogs[maxIndex].getWeight());
        //比较字符串内容是否相等时用 字符串提供的equals  不要用==
        InputStreamReader isr1=new InputStreamReader(System.in);
        BufferedReader br1= new BufferedReader(isr1);
        System.out.println("请输入狗的名字");
        String name= br1.readLine();
        //我TM想了一下午
            for (int j=0;j<dogs.length;j++)
            {
                if(name.equals(dogs[j].getName()))
                {
                    System.out.println("狗的体重是" + dogs[j].getWeight());
                    break;
                }
                //如果正好是3号狗j的值为3,然后会执行break退出
                else if(j==3)    //如果都没有这条狗j会变成3,执行这条语句
                {
                    System.out.println("没有这只狗");
                }
            }
    }

}
class Dog
{
    private String name;
    public float weight;
    public float getWeight() {
        return weight;
    }
    public void setWeight(float weight) {
        this.weight = weight;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

　　注：比较字符串内容是否相等时用String提供的equals方法，而不用==

数组小结

1. 数组可存放同一类型数据
2. 简单数据类型（int，float）数组，可直接赋值
3. 对象数组在定以后，赋值时需要再次为每个独享分配空间（即：new  对象）
4. 数组的大小必须事先指定
5. 数组名可以理解为执行数组首地址的引用
6. 数组的下标是从0开始编号的

排序（Sorting）

 　　排序是讲一群数据，依指定的顺序进行排列的过程。

排序的分类

1. 内部排序：指将需要处理的数据都加载到内部存储器中进行排序。
   包括（交换式排序法，选择式排序法和插入式排序法）
2. 外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
   包括（合并排序法和直接合并排序法）

排序是数据处理中一种很重要的算法，同时也是常用的算法，一般数据处理工作的25%的时间都在继续那你给排序。简单地说，排序就是把一组记录（元素）按照递增或递减的次序重新排列的过程。

交换式排序法

　　交换式排序属于内部排序法，是运用数据值比较后，依判断规则对数据位置进行交换，一打到排序的目的。

交换式排序法又可分为两种：

1、冒泡排序法（Bubble sort）

　　核心思想：依次比较，使数值小（或大）的元素逐渐向前移动

public class test7 
{
    public static void main(String[] args) 
    {
        int arr[]={1,6,0,-1,9};
        Bubble bubble = new Bubble();
        bubble.sort(arr);
    }

}
class Bubble
{
    //排序王法
    public void sort(int arr[])
    {
        int temp=0;
        //排序开始
        //外层循环——它决定一共走几趟
        for(int i=0;i<arr.length-1;i++)
        {
            //内层循环,开始逐个比较,如果发现前一个数比后一个数大,则交换
            for(int j=0;j<arr.length-1-i;j++)
            {
                if(arr[j]>arr[j+1])
                {
                    //换位
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                
            }
        }
        //输出最后结果
        for(int i=0;i<arr.length;i++)
        {
            System.out.println(arr[i]);
        }
    }
}

　　这里直接把数组传递到了方法中进行排序，传递的是引用，所以会直接改变数组的内容
　　但是基本数据类型并不是传引用，所以基本数据类型不会被类中的方法改变

public class test8 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a=12;
        Test test1=new Test();
        test1.test(a);
        System.out.println(a);
        
    }

}
class Test
{
    public void test(int a)
    {
        a++;
        System.out.println(a);
    }
}

输出结果：
13
12

2、快速排序法（Quick sort）

　　是对冒泡排序的一种改进。基本思想：在所有的数中找一个基准，然后将数分成两拨，一拨大于这个基准，一波小于这个基准。然后在对这两拨数进行相同的操作，这道所有的数都成为基准，也就意味着所有的数都有的次序。

图解：

package project1;

import java.util.*;

public class test2 {
    public static void main (String[] args) 
    {
        int arr1[]={-1,4,-3,7,34,98,0};
        int len = 100000;
        int[] arr2 = new int[len];
        for(int i=0;i<len;i++)
        {
            //让程序产生一个1-10000数
            //Math.random会随机产生一个0-1的数
            int t=(int)(Math.random()*100000);
            arr2[i] = t;
        }
        System.out.print("hello");
        QuickSort qs = new QuickSort();
        
        Calendar cal = Calendar.getInstance();
        System.out.println("排序前: "+cal.getTime());
        
        qs.sort(0,arr1.length-1,arr1);
        
        cal = Calendar.getInstance();
        System.out.println("排序前: "+cal.getTime());
        
        for(int i=0;i<arr1.length;i++)
        {
            System.out.print(arr1[i]+"  ");
        }
    }
}
class QuickSort{
    public void sort(int left,int right,int arr[]){
        int l=left;
        int r=right;
        int pivot=arr[(left+right)/2];
        int temp=0;
        while(l<r){
            while(arr[l]<pivot) l++;
            while(arr[r]>pivot) r--;
            if(l>=r) break;
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;
            if(arr[l]==pivot) --r;
            if(arr[r]==pivot) ++l;
        }
        if(l==r){
            l++;
            r--;
        }
        if(left<r) sort(left,r,arr);
        if(right>l) sort(l,right,arr);
    }
}

选择式排序法

　　选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，经过和其他元素重整，在依原则交换位置后达到排序的目的

选择式排序法又可分为两种

1、选择排序法（Selection Sort）

　　核心思想：0-9，10个元素，选出最小的放到0上，然后从1-9中选出最小的放到1上，以此类推、

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

        int arr[]={1,6,0,-1,9};

        Select select = new Select();
        select.sort(arr);    
    }

}
class Select
{
    public void sort(int arr[])
    {
        
        for(int j=0;j<arr.length-1;j++)
        {
            int temp=0;
            int min = arr[j];
            int minIndex=j;
            for(int k=j+1;k<arr.length;k++)
            {
                if(min>arr[k])
                {
                    min = arr[k];
                    minIndex=k;
                }
            }
            
            temp=arr[j];
            arr[j] = arr[minIndex];
            arr[minIndex] = temp;
        }
        for(int i=0;i<arr.length;i++)
        {
            System.out.println(arr[i]);
        }
    }
}

2、堆排序法（Heap Sort）

比较两个排序方法的速度

import java.util.*;

public class test9 
{
    public static void main(String[] args) 
    {
        int len = 100000;
        int[] arr = new int[len];
        for(int i=0;i<len;i++)
        {
            //让程序产生一个1-10000数
            //Math.random会随机产生一个0-1的数
            int t=(int)(Math.random()*100000);
            arr[i] = t;
        }
        System.out.println("选择排序接受挑战");
        Select select = new Select();
        //排序前打印一个时间
        Calendar cal=Calendar.getInstance();//单态模式,系统里面只有一个实例
        System.out.println("排序前"+cal.getTime());
        select.sort(arr);
        //重新得到实例，因为是单态的
        cal=Calendar.getInstance();
        System.out.println("排序后"+cal.getTime());
        
        System.out.println("冒泡排序接受挑战");
        Bubble bubble=new Bubble();
        cal=Calendar.getInstance();
        System.out.println("排序前"+cal.getTime());
        bubble.sort(arr);
        cal=Calendar.getInstance();
        System.out.println("排序后"+cal.getTime());
        
    }

}
class Select
{
    public void sort(int arr[])
    {
        
        for(int j=0;j<arr.length-1;j++)
        {
            int temp=0;
            int min = arr[j];
            int minIndex=j;
            for(int k=j+1;k<arr.length;k++)
            {
                if(min>arr[k])
                {
                    min = arr[k];
                    minIndex=k;
                }
            }
            
            temp=arr[j];
            arr[j] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

class Bubble
{
    public void sort(int arr[])
    {
        int temp=0;
        for(int i=0;i<arr.length-1;i++)
        {
            for(int j=0;j<arr.length-1-i;j++)
            {
                if(arr[j]>arr[j+1])
                {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                
            }
        }
    }
}

结果是：

选择排序接受挑战
排序前Thu Sep 20 16:15:20 CST 2018
排序后Thu Sep 20 16:15:28 CST 2018
冒泡排序接受挑战
排序前Thu Sep 20 16:15:28 CST 2018
排序后Thu Sep 20 16:15:42 CST 2018

插入式排序法　　

 　　插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

插入式排序法可分为三种

1、插入排序法（Insertion sort）

 　　核心思想：两个数列一个有序，一个无序，开始时有序表只包含一个元素，无需表包含n-1个元素，从无需表中取一个元素，然后依次和有序表中的排序码进行比较，将它插入到合适的位置

public class test 
{
    public static void main(String[] args) {
        int arr[]={-1,4,7,34,98,0};
        InsertSort insertsort = new InsertSort();
        insertsort.sort(arr);
        for(int i=0;i<arr.length;i++)
        {
            System.out.println(arr[i]);
        }

    }
}

class InsertSort
{
    public void sort(int arr[])
    {
        for(int i=1;i<arr.length;i++)
        {
            //从arr数列中拿出一个数来
            int insertVal = arr[i];        //和前一个数比较
            int index = i-1;    //index就是前面的数
            while(index>=0 && insertVal<index)
            {
                //就把arr[index]向后移动
                arr[index+1]=arr[index];//将index向后移动,腾出空间来
                index--;
            }//一直循环到前面的数比insertVal小为止然后把insertVal放到这个数后边
            //或者当index--变成负数的时候,也就是要插入的数是最小的时候
            arr[index+1] = insertVal;//
        }
        
    }
}

2、希尔排序法（Shell sort）

3、二叉树排序法（Binary-tree sort）

 查找

1、顺序查找

2、二分查找

核心思想：运用递归每次都找中间的数

public class pra1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = {2,5,7,12,25};
        BinaryFind bf = new BinaryFind();
        //传递的数组的引用,也就直接对数组操作
        bf.find(0, arr.length - 1, 12, arr);
    }

}

class BinaryFind
{
    public void find(int leftIndex,int rightIndex,int val,int arr[])
    {
        //首先找到中间的数
        int midIndex=(rightIndex+leftIndex)/2;
        int midVal = arr[midIndex];
        
        if(rightIndex>=leftIndex)//如果没有数,用它来保障可以跳出递归
        {
            //如果要找的数比midVal大
            if(midVal>val){
                //在arr左边数中找
                find(leftIndex,midIndex-1,val,arr);
            }
            else if(midVal<val)
            {
                find(midIndex+1,rightIndex,val,arr);
            }
            else if(midVal == val)
            {
                System.out.println("找到下标"+midIndex);
            }
        }
    }    
}

多维数组

三维四维都不用，即使是3D MAX也用不到这些东西，3Dmax中会使用封装好的东西

二维数组

1、定义

语法:
类型  数组名  [][]  =  new  类型[大小][大小]

例如:
int  a[][]  =  new  int[2][3]

2、二维数组在内存中的存放形式　

3、案例，请用二维数组输出如下图形

　　0 0 0 0 0 0
　　0 0 1 0 0 0 
　　0 2 0 3 0 0 
　　0 0 0 0 0 0 

public class pra {
    public static void main(String[] args) {
        int a[][] = new int[4][6];//简单的数据类型定义就可以用
        //数组中未给值的元素默认都是0
        a[1][2] = 1;
        a[2][1] = 2;
        a[2][3] = 3;
        
        //把图形输出
        for (int i=0;i<4;i++)    //行
        {
            for(int j=0;j<6;j++)    //列
            {
                System.out.print(a[i][j]+" ");
            }
            //换行
            System.out.println();
        }        
    }
}