数组
为什么要有数组?
案例:一个养鸡场有六只鸡,他们的体重分别为3kg,5kg,1kg,3.4kg,2kg,50kg。请问这六只鸡的总体重和平均体重是多少?
1 public classtest52 {3 public static voidmain(String[] args)4 {5 //如果没有数组就要定义六个变量,然后算出结果,太麻烦了6 //现在我们定义一个可以存放6个float类型的数组
7 float arr[] = new float[6];8 //给数组的各个元素赋值
9 arr[0] = 3; //3是低精度会自动转成高精度的float类型
10 arr[1] = 5;11 arr[2] = 1;12 arr[3] = 3.4f; //java中默认小数是double的所以在后面加上f说明是float类型,避
13 arr[4] = 2;14 arr[5] = 50;15
16 float all = 0;17 for(int i=0;i<6;i++) //遍历数组
18 {19 all +=arr[i];20 }21 System.out.println("总体中是" +all);22 }23 }
数组
数组可以存放多个同一类型的数据
数组的语法
//数组的定义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 classtest5
{public static voidmain(String[] args)
{float arr[] = {1.2f,2,3,4,5,7.8f};float all = 0;for(int i=1;i
{
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 classtest6
{public static voidmain(String[] args)
{//定义一个可以存放四只狗的对象数组
Dog dogs[] = new Dog[4];//给每只狗赋值
dogs[0].setName("花花");
dogs[0].setWeight(4.5f);
}
}classDog
{privateString name;public floatweight;public floatgetWeight() {returnweight;
}public void setWeight(floatweight) {this.weight =weight;
}publicString getName() {returnname;
}public voidsetName(String name) {this.name =name;
}
}
报错:空指针异常
java.lang.NullPointerException
经典错误——空指针异常
Java中没有指针,但引用的实质就是一个指针,引用里面存放的并不是对象而是该对象的地址,使得该引用指向了对象那个。而“=”在JAVA中并不该被翻译成赋值语句,因为他执行的是传递至的过程。
1 public classtest62 {3 public static voidmain(String[] args)4 {5 //定义一个可以存放四只狗的对象数组
6 Dog dogs[] = new Dog[4]; //仅仅创建了四个引用7
8 //给每只狗赋值
9 dogs[0] = new Dog(); //创建Dog()对象,然后传递给dogs[0]引用
10 dogs[0].setName("花花");11 dogs[0].setWeight(4.5f);12 }13
14 }15 classDog16 {17 privateString name;18 public floatweight;19 public floatgetWeight() {20 returnweight;21 }22 public void setWeight(floatweight) {23 this.weight =weight;24 }25 publicString getName() {26 returnname;27 }28 public voidsetName(String name) {29 this.name =name;30 }31 }
正确的代码
1 import java.io.*;2
3 public classtest64 {5 public static void main(String[] args) throwsException6 {7 //定义一个可以存放四只狗的对象数组
8 Dog dogs[] = new Dog[4]; //仅仅创建了四个引用9 //从控制台输入各个狗的信息
10 InputStreamReader isr=newInputStreamReader(System.in);11 BufferedReader br= newBufferedReader(isr);12 for(int i=0 ; i<4 ; i++)13 {14 dogs[i] = newDog();15 System.out.println("请输入狗的名子");16 //从控制台读取狗名
17 String name = br.readLine(); //之后会讲异常18 //讲名字赋值给对象
19 dogs[i].setName(name);20 System.out.println("请输入狗的体重");21 String s_weight =br.readLine();22 float weight = Float.parseFloat(s_weight);//String->float23 //讲名字赋值给对象
24 dogs[i].setWeight(weight);25 }26 //计算总体重
27 float allWeight = 0;28 for(int i=0;i<4;i++)29 {30 allWeight+=dogs[i].getWeight();31 }32 //计算平均体重
33 float avgWeight = allWeight/dogs.length;34 System.out.println("总体重="+allWeight+"平均体重"+avgWeight);35 }36
37 }38 classDog39 {40 privateString name;41 public floatweight;42 public floatgetWeight() {43 returnweight;44 }45 public void setWeight(floatweight) {46 this.weight =weight;47 }48 publicString getName() {49 returnname;50 }51 public voidsetName(String name) {52 this.name =name;53 }54 }
案例的全部代码
找出体重最大的狗,且输入狗的名字,返回体重
1 import java.io.*;2
3 public classtest64 {5 public static void main(String[] args) throwsException6 {7 //定义一个可以存放四只狗的对象数组
8 Dog dogs[] = new Dog[4]; //仅仅创建了四个引用9 //从控制台输入各个狗的信息
10 InputStreamReader isr=newInputStreamReader(System.in);11 BufferedReader br= newBufferedReader(isr);12 for(int i=0 ; i<4 ; i++)13 {14 dogs[i] = newDog();15 System.out.println("请输入狗的名子");16 //从控制台读取狗名
17 String name = br.readLine(); //之后会讲异常18 //讲名字赋值给对象
19 dogs[i].setName(name);20 System.out.println("请输入狗的体重");21 String s_weight =br.readLine();22 float weight = Float.parseFloat(s_weight);//String->float23 //讲名字赋值给对象
24 dogs[i].setWeight(weight);25 }26 //计算总体重
27 float allWeight = 0;28 for(int i=0;i<4;i++)29 {30 allWeight+=dogs[i].getWeight();31 }32 //计算平均体重
33 float avgWeight = allWeight/dogs.length;34 System.out.println("总体重="+allWeight+"平均体重"+avgWeight);35
36 //找出最大体重的狗37 //假设第一只狗体重最大
38 float maxWeight = dogs[0].getWeight();39 int maxIndex=0;40 //按顺序和后面的狗比较
41 for(int i=1;i
46 maxWeight=dogs[i].getWeight();47 maxIndex=i;48 }49 }50 System.out.println("体重最大的狗是第"+(maxIndex+1)+"体重是"+dogs[maxIndex].getWeight());51 //比较字符串内容是否相等时用 字符串提供的equals 不要用==
52 InputStreamReader isr1=newInputStreamReader(System.in);53 BufferedReader br1= newBufferedReader(isr1);54 System.out.println("请输入狗的名字");55 String name=br1.readLine();56 //我TM想了一下午
57 for (int j=0;j
65 else if(j==3) //如果都没有这条狗j会变成3,执行这条语句
66 {67 System.out.println("没有这只狗");68 }69 }70 }71
72 }73 classDog74 {75 privateString name;76 public floatweight;77 public floatgetWeight() {78 returnweight;79 }80 public void setWeight(floatweight) {81 this.weight =weight;82 }83 publicString getName() {84 returnname;85 }86 public voidsetName(String name) {87 this.name =name;88 }89 }
好不容易想出来的怎么返回“没有这只狗”
注:比较字符串内容是否相等时用String提供的equals方法,而不用==
数组小结
数组可存放同一类型数据
简单数据类型(int,float)数组,可直接赋值
对象数组在定以后,赋值时需要再次为每个独享分配空间(即:new 对象)
数组的大小必须事先指定
数组名可以理解为执行数组首地址的引用
数组的下标是从0开始编号的
排序(Sorting)
排序是讲一群数据,依指定的顺序进行排列的过程。
排序的分类
内部排序:指将需要处理的数据都加载到内部存储器中进行排序。
包括(交换式排序法,选择式排序法和插入式排序法)
外部排序法:数据量过大,无法全部加载到内存中,需要借助外部存储进行排序。
包括(合并排序法和直接合并排序法)
排序是数据处理中一种很重要的算法,同时也是常用的算法,一般数据处理工作的25%的时间都在继续那你给排序。简单地说,排序就是把一组记录(元素)按照递增或递减的次序重新排列的过程。
交换式排序法
交换式排序属于内部排序法,是运用数据值比较后,依判断规则对数据位置进行交换,一打到排序的目的。
交换式排序法又可分为两种:
1、冒泡排序法(Bubble sort)
核心思想:依次比较,使数值小(或大)的元素逐渐向前移动
1 public classtest72 {3 public static voidmain(String[] args)4 {5 int arr[]={1,6,0,-1,9};6 Bubble bubble = newBubble();7 bubble.sort(arr);8 }9
10 }11 classBubble12 {13 //排序王法
14 public void sort(intarr[])15 {16 int temp=0;17 //排序开始18 //外层循环——它决定一共走几趟
19 for(int i=0;i
22 for(int j=0;jarr[j+1])25 {26 //换位
27 temp =arr[j];28 arr[j] = arr[j+1];29 arr[j+1] =temp;30 }31
32 }33 }34 //输出最后结果
35 for(int i=0;i
Bubble sort
这里直接把数组传递到了方法中进行排序,传递的是引用,所以会直接改变数组的内容
但是基本数据类型并不是传引用,所以基本数据类型不会被类中的方法改变
1 public classtest8 {2 public static voidmain(String[] args) {3 //TODO Auto-generated method stub
4 int a=12;5 Test test1=newTest();6 test1.test(a);7 System.out.println(a);8
9 }10
11 }12 classTest13 {14 public void test(inta)15 {16 a++;17 System.out.println(a);18 }19 }20
21 输出结果:22 13
23 12
类方法接收基本数据类型
2、快速排序法(Quick sort)
是对冒泡排序的一种改进。基本思想:在所有的数中找一个基准,然后将数分成两拨,一拨大于这个基准,一波小于这个基准。然后在对这两拨数进行相同的操作,这道所有的数都成为基准,也就意味着所有的数都有的次序。
图解:
1 packageproject1;2
3 import java.util.*;4
5 public classtest2 {6 public static voidmain (String[] args)7 {8 int arr1[]={-1,4,-3,7,34,98,0};9 int len = 100000;10 int[] arr2 = new int[len];11 for(int i=0;i
15 int t=(int)(Math.random()*100000);16 arr2[i] =t;17 }18 System.out.print("hello");19 QuickSort qs = newQuickSort();20
21 Calendar cal =Calendar.getInstance();22 System.out.println("排序前: "+cal.getTime());23
24 qs.sort(0,arr1.length-1,arr1);25
26 cal =Calendar.getInstance();27 System.out.println("排序前: "+cal.getTime());28
29 for(int i=0;ipivot) r--;44 if(l>=r) break;45 temp=arr[l];46 arr[l]=arr[r];47 arr[r]=temp;48 if(arr[l]==pivot) --r;49 if(arr[r]==pivot) ++l;50 }51 if(l==r){52 l++;53 r--;54 }55 if(leftl) sort(l,right,arr);57 }58 }
quick sort
选择式排序法
选择式排序也属于内部排序法,是从欲排序的数据中,按指定的规则选出某一元素,经过和其他元素重整,在依原则交换位置后达到排序的目的
选择式排序法又可分为两种
1、选择排序法(Selection Sort)
核心思想:0-9,10个元素,选出最小的放到0上,然后从1-9中选出最小的放到1上,以此类推、
1 public classtest9_22 {3 public static voidmain(String[] args)4 {5
6 int arr[]={1,6,0,-1,9};7
8 Select select = newSelect();9 select.sort(arr);10 }11
12 }13 classSelect14 {15 public void sort(intarr[])16 {17
18 for(int j=0;jarr[k])26 {27 min =arr[k];28 minIndex=k;29 }30 }31
32 temp=arr[j];33 arr[j] =arr[minIndex];34 arr[minIndex] =temp;35 }36 for(int i=0;i
Select sort
2、堆排序法(Heap Sort)
比较两个排序方法的速度
1 import java.util.*;2
3 public classtest94 {5 public static voidmain(String[] args)6 {7 int len = 100000;8 int[] arr = new int[len];9 for(int i=0;i
13 int t=(int)(Math.random()*100000);14 arr[i] =t;15 }16 System.out.println("选择排序接受挑战");17 Select select = newSelect();18 //排序前打印一个时间
19 Calendar cal=Calendar.getInstance();//单态模式,系统里面只有一个实例
20 System.out.println("排序前"+cal.getTime());21 select.sort(arr);22 //重新得到实例,因为是单态的
23 cal=Calendar.getInstance();24 System.out.println("排序后"+cal.getTime());25
26 System.out.println("冒泡排序接受挑战");27 Bubble bubble=newBubble();28 cal=Calendar.getInstance();29 System.out.println("排序前"+cal.getTime());30 bubble.sort(arr);31 cal=Calendar.getInstance();32 System.out.println("排序后"+cal.getTime());33
34 }35
36 }37 classSelect38 {39 public void sort(intarr[])40 {41
42 for(int j=0;jarr[k])50 {51 min =arr[k];52 minIndex=k;53 }54 }55
56 temp=arr[j];57 arr[j] =arr[minIndex];58 arr[minIndex] =temp;59 }60 }61 }62
63 classBubble64 {65 public void sort(intarr[])66 {67 int temp=0;68 for(int i=0;iarr[j+1])73 {74 temp =arr[j];75 arr[j] = arr[j+1];76 arr[j+1] =temp;77 }78
79 }80 }81 }82 }
生成10000个数进行排序
结果是:
选择排序接受挑战
排序前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个元素,从无需表中取一个元素,然后依次和有序表中的排序码进行比较,将它插入到合适的位置
1 public classtest2 {3 public static voidmain(String[] args) {4 int arr[]={-1,4,7,34,98,0};5 InsertSort insertsort = newInsertSort();6 insertsort.sort(arr);7 for(int i=0;i
12 }13 }14
15 classInsertSort16 {17 public void sort(intarr[])18 {19 for(int i=1;i
22 int insertVal = arr[i]; //和前一个数比较
23 int index = i-1; //index就是前面的数
24 while(index>=0 && insertVal
27 arr[index+1]=arr[index];//将index向后移动,腾出空间来
28 index--;29 }//一直循环到前面的数比insertVal小为止然后把insertVal放到这个数后边30 //或者当index--变成负数的时候,也就是要插入的数是最小的时候
31 arr[index+1] = insertVal;//32 }33
34 }35 }
Insert Sort
2、希尔排序法(Shell sort)
3、二叉树排序法(Binary-tree sort)
查找
1、顺序查找
2、二分查找
核心思想:运用递归每次都找中间的数
1 public classpra1 {2
3 /**
4 *@paramargs5 */
6 public static voidmain(String[] args) {7 //TODO Auto-generated method stub
8 int arr[] = {2,5,7,12,25};9 BinaryFind bf = newBinaryFind();10 //传递的数组的引用,也就直接对数组操作
11 bf.find(0, arr.length - 1, 12, arr);12 }13
14 }15
16 classBinaryFind17 {18 public void find(int leftIndex,int rightIndex,int val,intarr[])19 {20 //首先找到中间的数
21 int midIndex=(rightIndex+leftIndex)/2;22 int midVal =arr[midIndex];23
24 if(rightIndex>=leftIndex)//如果没有数,用它来保障可以跳出递归
25 {26 //如果要找的数比midVal大
27 if(midVal>val){28 //在arr左边数中找
29 find(leftIndex,midIndex-1,val,arr);30 }31 else if(midVal
Binary Find
多维数组
三维四维都不用,即使是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
1 public classpra {2 public static voidmain(String[] args) {3 int a[][] = new int[4][6];//简单的数据类型定义就可以用4 //数组中未给值的元素默认都是0
5 a[1][2] = 1;6 a[2][1] = 2;7 a[2][3] = 3;8
9 //把图形输出
10 for (int i=0;i<4;i++) //行
11 {12 for(int j=0;j<6;j++) //列
13 {14 System.out.print(a[i][j]+" ");15 }16 //换行
17 System.out.println();18 }19 }20 }
二维数组