数组
目录
数组的定义
特殊的数据空间，它用来表示多个相同类型的数据的空间，而且空间是连续的。
数组中存放的数据，叫做元素
下标，代表该元素在数组的位置（下标都是从0开始的，最大到数组的大小-1）
元素类型 ：数据的类型
一维数组
1.语法
声明一维数组：
type 数组名[];
或者
type[] 数组名 申请空间，指明空间大小（数据的个数）：
例如：5个学生的成绩。假定：学员的成绩都是整数
int scores[] ;// 声明
scores = new int[5];// 申请空间注意：声明数组和申请空间可以合并为一个步骤：
int arr[]= new int[5];// 声明数组和申请空间可以合并申请空间，系统会给每个数组元素设置一个默认值。
| 数据类型 | 默认值 |
|---|---|
| 整型（byte,short,int,long） | 0 |
| 浮点型（double,float） | 0.0 |
| char型 | 空格 |
| boolean型 | false |
| 引用数据类型（数组，接口、类） | null |
2.初始化
2.1 动态初始化
指明数组的大小。适合于数组长度较大的情况
int arr[] = new int[5];2.2 静态初始化
由数据确定数组的大小，无需指明大小。适合于数组长度较小的情况
int arr[]={1,2,3,4};
// 或者
int arr2[]=new int[]{1,2,3,4};3.访问数组元素
通过下标访问数组的元素，需要注意下标越界的问题，若下标超出范围则报ArrayIndexOutOfBoundsException异 常。
比如：数组的长度（大小）5个
下标的范围（0-4）
int arr[]=new int[4];
// 访问第一个元素arr[0]
System.out.println(arr[0]);
4.数组的属性
length代表数组的长度，可以动态的获取数组的长度。
数组名.length; 获取数组的长度
5.操作
1.遍历
将数组中的每个元素输出,使用循环遍历（for）
int n = arr.length;// 数据的个数
for (int i=0 ; i < n ; i++){
System.out.print(arr[i]+" ");
}
System.out.println();// 换行
// for循环
// 使用集合对象，类型相同
int arr[]={1,2,3,4};
int count=1,index=0; // count序号 index索引
for(int a:arr){
System.out.println("当前是第"+count+"个元素："+a+" 其索引号为："+index);
count++;
index++;
}
String arr2[]={"123","2332","33"};
for(String str:arr2){
System.out.print(str+" ");
}
System.out.println();2.反转--首尾交换
for(int i=0,j=arr.length‐1;i<j;i++,j‐‐){
int temp ;//中间变量
temp = arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
3.查找数据对应的下标（索引）
比如，有一个数组【1 , 2 , 3 , 4 , 5 , 6 , 7】，从键盘上输入一个数值，查询该数值在数组的中的下标，若找到则返 回其下标，若找不到则返回-1；
// 接收键盘输入
Scanner scanner =new Scanner(System.in);
// 提醒输入数据
System.out.println("请输入一个整数：");
int num = scanner.nextInt();// 接收键盘输入的数字，赋值给num
int index =‐1;// 表示索引值
// 遍历数组，num 和数组中的元素值进行比较
for(int i=0;i<arr.length;i++){
if(arr[i]==num){
index =i;// 下标值赋值给index变量
break;// 跳出循环体
}
}6.基于数组的算法
排序（冒泡排序），升序
n个数字来排序
共比较n-1轮
相邻的数字比较，大的后移
每轮的次数n-1-i
int n = arr.length;// 数据的个数
// 外层循环确定比较轮次
for(int i=0;i< n‐1;i++){
// 每次比较的次数
// i=0,n=4;
// j<3 带入法判断结束条件
for(int j=0;j < n‐i‐1;j++){
int temp ;//中间变量
if(arr[j] > arr[j+1]){
// 前头的数据大于后的数据，进行交换
temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}相邻数字比较，若小的后移，降序
多维数组
数组的数组，相当于数组的元素是数组
超过二维数组的用的比较少，一般情况掌握二维数组
二维数组
1.语法
// 声明
type arr[][];
或者：
type[][] arr;
2.初始化
2.1 动态初始化
int arr[][];
int arr2[][];
// 申请空间
arr = new int[2][3];
arr2=new int[2][];
// 两个数字
第一个数字：维数(也是二维数组的大小),不能省略；
第二个数字：一维数组的元素个数，可以省略，省略表示其元素的值为null
其数组中元素的值，是系统默认的
注意：声明和申请空间可以合并
int arr[][] =new int[2][3]; 2.2 静态初始化
定义数组的同时给数组元素赋值。
int arr[][] = new int[][]{
{},{}
};
// 简写
int arr2[][]={
{1,2,3}, {1}, {2,3,3,3,4},
};// 不规则，其二维数组中元素的个数是不同的
int arr3[][]={
{1,2,3}, {1,2,3}, {2,3,3},
};// 规则3.属性length
二维数组的长度
int arr[][] ={
{1,2,3}, {2,3,4}
}
int len = arr.length;// 获取二维数组的维数4.操作
1.访问：
通过下标：行 列，都是从零开始计算的。也需要注意下标越界的问题
// 输出二维数组中的第一元素的值
System.out..println(arr3[0][0]);2.遍历
两层遍历
第一层循环遍历二维数组中的元素（一维数组），遍历行
第二层循环遍历二维数组的每个元素，遍历列
int arr[][]={
{1,2,3},
{1},
{2,3,3,3,4}
};
int length = arr.length;
System.out.println(arr.length);
for(int i=0;i<length;i++){
int length2 = arr[i].length;// 二维数组的元素的大小
for(int j=0;j<length2;j++){
System.out.print(arr[i][j]+" ");
}
System.out.println();
}例：
杨辉三角序列
1
11
121
1331
import java.util.Scanner;
public class yhprac02 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("out len:");
int len = sc.nextInt();
int arr[][] = new int[len][];
//行数
for(int i=0;i<len;i++) {
arr[i] = new int[i+1];
//列数
for(int j=0;j<arr[i].length;j++) {
if(j==0 || j==arr[i].length-1) {
arr[i][j]=1;
}else {
arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
}
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}
简单的停车场管理系统
车位 （10） 车牌号（4位数字）
入库（）
1.有空车位，入库，记录开始时间
出库（）
1.车牌号，找车位，计算停车费用
收费规则：不足20分钟不收费,超过20分钟按一个小时计费
一小时收费标准2元
使用控制台程序来做！没有界面 ，swing
import java.util.Scanner;
import java.util.Date;
public class work02 {
/**一维数组方式
* 车辆入库和出库
* 停车计费标准:1小时2块，不足20分不收钱，
* 超过20分不足一小时，则按一小时计
* @param args
*/
public static void main(String[] args) {
//字符数组定义车位location(默认null)
//若车位上有车，数组中放置车牌号card
String location[] = new String[10];//车位
Date inTime[] = new Date[10];//入库时间
location[0] = "0001";
inTime[0] = new Date(new Date().getTime()-125*60*1000);
// In(location, inTime);
// Out(location, inTime);
//主菜单
boolean isExit = false;
while (true) {
System.out.println("******************************************");
System.out.println("* *");
System.out.println("* 停车场管理系统 *");
System.out.println("* *");
System.out.println("* *");
System.out.println("* 1.入库 2.出库 3.退出 *");
System.out.println("******************************************");
System.out.println();
System.out.println("请输入你的选择：");
Scanner sc = new Scanner(System.in);
int select = sc.nextInt();
switch (select) {
case 1:
In(location, inTime);
break;
case 2:
Out(location, inTime);
break;
case 3:
isExit = true;
break;
default:
System.out.println("没有对应选项");
}
if (isExit) {
System.out.println("退出系统");
break;
}
}
}
//找空位
static int findLoc(String location[]) {
int index = -1;//无空闲车位
//遍历车位，找第一个空闲车位
for(int i=0;i < location.length;i++) {
//找到一个空车位
if(location[i] == null) {
index = i;
break;//找到后退出查询
}
}
return index;
}
//打印当前所有车位信息
static void print(String location[],Date inTime[]) {
//遍历车位
for (int i = 0;i < location.length;i++) {
if(location[i] == null) {
System.out.println("第"+(i+1)+"个车位NULL");//i从0开始
}else {
System.out.println("第"+(i+1)+"个车位已占用...车牌号"+location[i]+"...开始计时"+inTime[i]);
}
}
}
//入库
static void In(String location[], Date inTime[]) {
//找空位(index=-1表示没有位置)
int index = findLoc(location);
//如果找到空位
if(index > -1) {
System.out.println("找到一个空位"+(index+1)+"号车位");
System.out.print("请输入入库车牌号card:");
Scanner sc = new Scanner(System.in);
String card = sc.next();
//记录车牌号
location[index] = card;
//对应的入库时间
inTime[index] = new Date();
//打印入库后停车信息
print(location, inTime);
}else {//未找到车位
System.out.println("FULL");
}
}
//出库
static void Out(String[] location, Date[] inTime) {
System.out.println("请输入出库车牌号card:");
Scanner sc = new Scanner(System.in);
String card = sc.next();
//按照车牌号找匹配的车牌号
int indexCard = findIndex(card,location);
//找到对应车位,取出入库时间，当前时间-入库时间 = 停车时间 ，根据停车时间进行计费
if(indexCard > -1) {
System.out.println("该车牌号"+card+"对应的车位为："+location[indexCard]);
System.out.println();
//获取入库时间
Date C_inTime = inTime[indexCard];
//记录当前出库时间
Date C_Time = new Date();
//停车时间（毫秒）1秒=1000毫秒
long time = C_Time.getTime() - C_inTime.getTime();
//分钟
long minutes = time/1000/60;
//收费标准：
//不足20分钟不收费；超过20分钟按一个小时计费 一小时收费标准2元
//110 分钟 1小时 50 分钟 4元
//130分钟 2小时10 分钟 4元
//145分钟 2小时25 分钟 6元
if(minutes < 20) {
System.out.println("停车时间不足20分钟，不计费");
}else if(minutes >=20 && minutes <=60){
System.out.println("停车时间为"+minutes+"分钟(超过20分钟按一个小时计费),收费2元");
}else {
int money=0,money1=0;
int hours,minute=0;
hours = (int)(minutes/60);//得到小时数
if(minutes%60 != 0) {
minute = (int)(minutes%60);//得到不足一小时但大于20分钟
if(minute > 20) {
money1 = 2;
}
}
//总费用
money = hours * 2 + money1;
System.out.println("停车时间为"+hours+"小时"+minute+"分钟...计费:"+money+"元");
// 需要将对应的车位置为null,时间也置为null
location[indexCard] = null; // 出库后，将该车位上的车牌号置为null;
inTime[indexCard] = null;
print(location, inTime);
}
}else {
System.out.println("未找到对应车牌号的车位");
}
}
//通过车牌号找要出库的车位
static int findIndex(String card,String location[]){
//找车位，初始化为-1
int index =-1;
//遍历查找车位
for(int i=0;i<location.length;i++){
//找到了
if(card.equals(location[i])){
index = i;
break;
}else {
System.out.println("未找到车牌号为"+card+"的车位");
}
}
return index;
}
}
import java.util.Scanner;
import java.util.Date;
public class work03 {
/**二维数组方式
* 车辆入库和出库
* 停车计费标准:1小时2块，不足20分不收钱，
* 超过20分不足一小时，则按一小时计
* @param args
*/
public static void main(String[] args) {
//字符数组定义车位location(默认null)
//若车位上有车，数组中放置车牌号card
String location[][] = new String[10][2];//车位10个车位 0列车牌号 1列入库时间
Date inTime = new Date(new Date().getTime() - 125*60*1000);
//(举例) 在第一个车位上停了一辆车 车牌号0010
location[0][0] = "0001";
将停车时间转成日期时间字符串
location[0][1] = DateUtils.toStr(inTime);
// In(location);
// Out(location);
//主菜单
boolean isExit = false;
while (true) {
System.out.println("******************************************");
System.out.println("* *");
System.out.println("* 停车场管理系统 *");
System.out.println("* *");
System.out.println("* *");
System.out.println("* 1.入库 2.出库 3.退出 *");
System.out.println("******************************************");
System.out.println();
System.out.println("请输入你的选择：");
Scanner sc = new Scanner(System.in);
int select = sc.nextInt();
switch (select) {
case 1:
In(location);
break;
case 2:
Out(location);
break;
case 3:
isExit = true;
break;
default:
System.out.println("没有对应选项");
}
if (isExit) {
System.out.println("退出系统");
break;
}
}
}
//找空位
static int findLoc(String location[][]) {
int index = -1;//无空闲车位
//遍历车位，找第一个空闲车位
for(int i=0;i < location.length;i++) {
//找到一个空车位
if(location[i][0] == null) {
index = i;
break;//找到后退出查询
}
}
return index;
}
//打印当前所有车位信息
static void print(String location[][]) {
//遍历车位
for (int i = 0;i < location.length;i++) {
if(location[i][0] == null) {
System.out.println("第"+(i+1)+"个车位NULL");//i从0开始
}else {
System.out.println("第"+(i+1)+"个车位已占用...车牌号"+location[i][0]+"...开始计时"+location[i][1]);
}
}
}
//入库
static void In(String location[][]) {
//找空位(index=-1表示没有位置)
int index = findLoc(location);
//如果找到空位
if(index > -1) {
System.out.println("找到一个空位"+(index+1)+"号车位");
System.out.print("请输入入库车牌号card:");
Scanner sc = new Scanner(System.in);
String card = sc.next();
//记录车牌号
location[index][0] = card;
//对应的入库时间
location[index][1] = DateUtils.toStr(new Date());
//打印入库后停车信息
print(location);
}else {//未找到车位
System.out.println("FULL");
}
}
//出库
static void Out(String location[][]) {
System.out.println("请输入出库车牌号card:");
Scanner sc = new Scanner(System.in);
String card = sc.next();
//按照车牌号找匹配的车牌号
int indexCard = findIndex(card,location);
//找到对应车位,取出入库时间，当前时间-入库时间 = 停车时间 ，根据停车时间进行计费
if(indexCard > -1) {
System.out.println("该车牌号"+card+"对应的车位为："+location[indexCard][0]);
System.out.println();
//获取入库时间
Date C_inTime = DateUtils.toDate(location[indexCard][1]);
//记录当前出库时间
Date C_Time = new Date();
//停车时间（毫秒）1秒=1000毫秒
long time = C_Time.getTime() - C_inTime.getTime();
//分钟
long minutes = time/1000/60;
//收费标准：
//不足20分钟不收费；超过20分钟按一个小时计费 一小时收费标准2元
//110 分钟 1小时 50 分钟 4元
//130分钟 2小时10 分钟 4元
//145分钟 2小时25 分钟 6元
if(minutes < 20) {
System.out.println("停车时间不足20分钟，不计费");
}else if(minutes >=20 && minutes <=60){
System.out.println("停车时间为"+minutes+"分钟(超过20分钟按一个小时计费),收费2元");
}else {
int money=0,money1=0;
int hours,minute=0;
hours = (int)(minutes/60);//得到小时数
if(minutes%60 != 0) {
minute = (int)(minutes%60);//得到不足一小时但大于20分钟
if(minute > 20) {
money1 = 2;
}
}
//总费用
money = hours * 2 + money1;
System.out.println("停车时间为"+hours+"小时"+minute+"分钟...计费:"+money+"元");
// 需要将对应的车位置为null,时间也置为null
location[indexCard][0] = null; // 出库后，将该车位上的车牌号置为null;
location[indexCard][1] = null;
print(location);
}
}else {
System.out.println("未找到对应车牌号的车位");
}
}
//通过车牌号找要出库的车位
static int findIndex(String card,String location[][]){
//找车位，初始化为-1
int index =-1;
//遍历查找车位
for(int i=0;i<location.length;i++){
//找到了
if(card.equals(location[i][0])){
index = i;
break;
}else {
System.out.println("未找到车牌号为"+card+"的车位");
}
}
return index;
}
}
5.基于数组的工具类Arrays
提供了特定功能的类，系统自带的类。java.util
1. 二分查找法（binarySearch）
在数组查询某元素，若存在则返回该元素对应的索引；若不存在则返回负数
public static void main(String args[]){
int arr[]={1,2,3,4,11,23,24,45,67};
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要查询的数字：");
int num = scanner.nextInt();
// 参数1表示数组；参数2表示要查询的数据
int index = Arrays.binarySearch(arr,num);
System.out.println("该数字在数组中的索引位："+index);
}2. 数组填充数据（fill ）
// 定义整形数组，数组中的每个元素都赋值为1
int arr[]=new int[5];// 0
Arrays.fill(arr,1);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();3. 将数组转成字符串（toString ）
String str = Arrays.toString(arr);
System.out.println(str)输出的结果：
[1,1,1,1,1]
4. 数组进行排序 （sort）
byte bs[]={1,22,8,23,11,9};
// Arrays.sort
Arrays.sort(bs);
// 按照升序 基于冒泡排序的算法
System.out.println(Arrays.toString(bs));5.数组的复制
- copyof 参数1表示源数组；参数2表示拷贝数据的个数
// 从源数组拷贝n个数据到新数组
// 若n的数量大于源数组的数量，则多的数据按默认值来处理
// n =0 拷贝出来的是一个空的数组
// n <0 抛出异常
int arr[]={1,2,3};
int[] newArr = Arrays.copyOf(arr,0);
System.out.println(Arrays.toString(newArr));- copyOfRange 参数1：源数组；参数2(from)：开始位置；参数3(to)：截止位置（不含此位置上的数据）
// 若结束位置超出源数组的最大下标则多出的位置上的数据按默认值处理
// 若开始位置为负数，则会抛出数组越界异常
int arr[]={0,1,2,3,4,5,6,7,8,9};
int newArr[]= Arrays.copyOfRange(arr,‐1,12);
System.out.println(Arrays.toString(newArr));6. equals判断两个数组是否相同
//判断两个数组是否相同，比较的数组中每个元素；若相同则返回true；否则返回false;
int arr1[]={1,2,3};
int arr2[]={1,2,4};
boolean isXt = Arrays.equals(arr1,arr2);
System.out.println("两个数组是否相同："+isXt);
699
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
