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方法，而不用==
数组小结
- 数组可存放同一类型数据
- 简单数据类型（int，float）数组，可直接赋值
- 对象数组在定以后，赋值时需要再次为每个独享分配空间（即：new 对象）
- 数组的大小必须事先指定
- 数组名可以理解为执行数组首地址的引用
- 数组的下标是从0开始编号的
排序（Sorting）
排序是讲一群数据，依指定的顺序进行排列的过程。
排序的分类
- 内部排序：指将需要处理的数据都加载到内部存储器中进行排序。
包括（交换式排序法，选择式排序法和插入式排序法） - 外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
包括（合并排序法和直接合并排序法）
排序是数据处理中一种很重要的算法，同时也是常用的算法，一般数据处理工作的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]);
}
}
}
Bubble sort
这里直接把数组传递到了方法中进行排序，传递的是引用，所以会直接改变数组的内容
但是基本数据类型并不是传引用，所以基本数据类型不会被类中的方法改变
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);
}
}
quick sort
选择式排序法
选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，经过和其他元素重整，在依原则交换位置后达到排序的目的
选择式排序法又可分为两种
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]);
}
}
}
Select sort
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;
} }
}
}
}
生成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个元素，从无需表中取一个元素，然后依次和有序表中的排序码进行比较，将它插入到合适的位置
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;//
} }
}
Insert Sort
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);
}
}
}
}
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
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();
}
}
}
二维数组
Java学习日记基础篇（七) —— 数组、排序的更多相关文章
- Java学习日记基础篇（九) —— 集合框架，泛型，异常
集合框架 有事我们会需要一个能够动态的调整大小的数组,比如说要添加新员工但是数组已经满了,并且数组的大小是在定义的时候定死的,所以我们就需要一个能够动态调整大小的数组或者用链表解决,而java中提供了 ...
- Java学习日记基础篇（六）—— 抽象类、接口、final
抽象类 为什么要有抽象类? 因为父类方法有不确定性,我们在Animal中定义了一个方法,但是它会被子类的方法覆盖掉,我们就不知道这个方法原本是做什么的 public class test1 { pub ...
- Java学习日记基础篇（四）——类，对象之成员变量，成员方法，构造方法
面向对象(Object Oriented) 一.面向对象杂谈 面向对象(Object Oriented),我的翻译是以物体为目标的,就是说编程的时候是建立一个物体,然后对这个物体进行操作. Java语 ...
- Java学习日记——基础篇（二）基本语法
变量 变量和常量是程序处理的两种基本数据对象,变量是程序的基本组成单位 变量的目的就是确定目标并提供存放空间 public class Hello { public static void main( ...
- Java学习日记——基础篇（一）常识
JAVA简介 Java的标准 Java是一种语言,一个平台包含JavaSE.JavaEE.JavaME三个版本 JavaSE标准版(属于Java的基础部分,可以开发C/S构架的桌面应用程序) Java ...
- Java学习日记基础篇（八) —— 二进制、位运算、位移运算
二进制 二进制是逢2进位的进位置,0,1是基本算符 原码反码补码 在基本数据类型那里,有详细解释 二进制的最高位数是符号位:0表示整数,1表示负数 正数的原码,反码,补码都一样 负数的反码 = 它的原 ...
- Java学习日记基础篇（三-下）——流程控制之循环控制
循环控制 for循环 语法: for(循环初值;循环条件;步长) { 语句; //循环体 } 例子: import java.io.*; public class Demo4 { public sta ...
- Java学习日记——基础篇（三-上）基本语法之运算符和流程控制
运算符 算术运算符 听其名而知其意,就是用于计算的,java中常用的是: + 加 - 减 * 乘 / 除 % 取模,取余——%可以用来得到两个数相除的余数 小练习——写一个ja ...
- java学习笔记-基础篇
Java基础篇 1—12 常识 13 this关键字 14参数传递 16 继承 17 访问权限 28—31异常 1—12 常识 1.文件夹以列表展示,显示扩展名,在地址栏显示全路径 2.javac编译 ...
随机推荐
- javascript 之 call,apply原理
一.call原理 1.使用JQuery的call功能 var add(c,d){ return this.a+this.b+c+d } var obj={a:1,b:2} add.Call(obj,3 ...
- 遗传算法python实现
最近看了一下遗传算法,使用轮盘赌选择染色体,使用单点交叉,下面是代码实现(python3) import numpy as np import random from scipy.optimize i ...
- 步步截图的SMM框架入门实战指引（SpringBoot、Mybatis Plus、Maven）
前提是对spring.springmvc.mybatis有初步学习和理解,因为要全部讲这些框架的知识点太多了,自己学习,这里是实战示范(大部分人学了知识之后去实战会出现很多问题,所以出此教程) 开发环 ...
- sql server with as只能查询一次
WITH Emp AS (SELECT acc.* FROM GXSpreadDB.dbo.gxs_account acc LEFT JOIN RYAccountsDB.dbo.AccountsInf ...
- 前端框架开始学习Vue(一)
MVVM开发思想图(图片可能会被缩小,请右键另存查看,图片来源于网络) 定义基本Vue代码结构 1 v-text,v-cloak,v-html命令 默认 v-text没有闪烁问题,但是会覆盖元 ...
- git pull 的时候 把本地的修改 覆盖远程端
首先,git pull 可以分成两步,git fetch 和git merge 使用git branch -a可以看出来 git merge 相当于当前分支 和 origin/master分支 ...
- git相关的一篇不错的文章
原文地址:http://josh-persistence.iteye.com/blog/2215214 点击进入
- python之csv操作
在使用python爬虫时或者其他情况,都会用到csv存储与读取的相关操作,我们在这里就浅谈一下: CSV(Comma-Separated Values)逗号分隔符,也就是每条记录中的值与值之间是用分号 ...
- 如何使用Systemctl管理系统服务和单元?
chu原文:How To Use Systemctl to Manage Systemd Services and Units 简书:如何使用Systemctl管理系统服务和单元? 引言 System ...
- C++——异常处理
前言 大型和十分复杂的程序往往会产生一些很难查找的甚至是无法避免的运行时错误.当发生运行时错误时,不能简单地结束程序运行,而是退回到任务的起点,指出错误,并由用户决定下一步工作.面向对象的异常处理(e ...