-
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即：数组就是一组数据
例：有6只鸡，体重分别是3，5，1，3.4，2，50，计算他们的总体重和平均体重
public class Array01{
public static void main(String[] args){//double[] 表示的是 double类型的数组，数组名为 hens
double[] hens = {3, 5, 1, 3.4, 2, 50};//double hens[] = new double[6]
//遍历数组得到数组的所有元素的和，使用for循环
//1、可以通过hens【下标】来访问数组的元素，下标是从0开始编号的
//2、通过for循环就可以访问数组的元素
double sum = 0;
for(int i = 0;i < 6;i++){//一定要注意数组长度问题，否则会发生数组越界报错
//System.out.println("第"+(i+1)+"个元素的值是"+hens[i]);
sum += hens[i];
}
System.out.println("总体重为"+sum+"n"+"平均体重为"+sum / 6);
}
}
数组的使用
（1）动态初始化
-
定义：
数据类型 数组名【】 = new 数据类型【大小】
int a【】= new int 【5】//创建了一个数组，名字a，存放5个int
-
例
import java.util.Scanner
public class Array02{
public static void main(String[] args){
Scanner myScanner = new Scanner(System.in);
double a[] = new double[5];
for(int i = 0;i < a.length;i++){
System.out.println("请输入第"+(i+1)+"个人的成绩");
a[i] = myScanner.nextDouble();
}
System.out.println("----得到的成绩如下----");
for(int j = 0;j < a.length;j++){
System.out.println("第"+(j+1)+"个元素的值为"+a[j]);
}
}
}
- 数组使用注意事项和细节
（1）数组是多个相同数据类型的组合，实现对这些数据的统一管理
（2）数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型，但不能混用
（3）数组创建后，如果没有赋值，则数组会自动赋予默认值
（4）使用数组的步骤：
①声明数组并开辟空间
②给数组各个元素赋值
③使用数组
（5）数组的下标是从0开始的
（6）数组下标必须在指定范围内使用，否则报错：下标越界异常
（7）数组属于引用数据类型，数组型数据的对象是（object）
-
例题
（1）创建一个char类型的26个元素的数组，分别放置A-Z。使用for循环放分所有元素并打印出来
public class Array03{
public static void main(String[] args){
char words[] = new char[26];
for(int i = 0;i < words.length;i++){
words[i]=(char)('A' + i);//强制转换
}
for(int j = 0;j < words.length;j++){
System.out.print(words[j]+" ");
}
}
}
2）请求出一个数组int【】的最大值{4，-1，9，10，23}，并得到对应的下标
public class Array04{
public static void main(String[] args){
int i = 0;
int j = 0;//找下标值
int a[] = {4,-1,9,10,23};
for (i = 0;i < 4;i++){
if(a[i+1]
-
数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值
public class Array05{
public static void main(String[] args){
int arr1[]={1,2,3};
int arr2[]=arr1;
arr2[0]=3;
for(int i = 0;i <= arr1.length;i++){
System.out,println(arr1[i]);}//输出3，2，3
}
}
数组反转
要求：把数组的元素内容反转
arr{11，22，33，44，55，66}→{66，55，44，33，22，11}
public class Array06{
public static void main(String[] args){
int arr1[] = {11,22,33,44,55,66};
int arr2[] = new int[arr1.length];
int j=0;
for(int i=(arr1.length-1);i>=0;i--){ //逆序遍历
for(j =(arr1.length-1)-i; j < 6-i;j++){
arr2[j] = arr1[i];
}
System.out.println(arr2[j-1]);
}//这种方法arr1的值并没有变
}
}
数组添加
要求：实现动态的给数组增加元素的效果，实现对数组扩容
（1）原始数组使用静态分配 int【】arr = {1，2，3}
（2）增加的元素4，直接放在数组的最后 arr = {1，2，3，4}
（3）用户可以通过如下方式来决定是否继续添加，添加成功，是否继续？
import java.util.Scanner;
public class Array07{
public static void main(String[] args){
int arr [] = {1,2,3};
Scanner myScanner = new Scanner(System.in);
do{
int arr2 [] = new int[arr.length+1];//在arr数组的长度上+1
System.out.println("请输入您要添加的数");
for(int i = 0;i < arr.length;i++){
arr2[i]=arr[i];//把原来的数组赋给arr2
}
arr2[arr2.length-1]=myScanner.nextInt();//让多了的一个元素给arr2
arr = arr2;
for(int i = 0; i < arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println("恭喜您添加成功，请确定是否继续，y/n");
char key = myScanner.next().charAt(0);
if(key == 'n'){
break;
System.out.println("添加结束");
}
}while(true);
}
}
变形：数组缩减
public class Array08{
public static void main(String[] args){
int arr [] = {1,2,3,4};
do{
int arr2 [] = new int[arr.length-1];//在arr数组的长度上-1
for(int i = 0;i < arr.length-1;i++){
arr2[i]=arr[i];//把原来的数组赋给arr2
}
arr = arr2;
for(int i = 0; i < arr2.length;i++){
System.out.print(arr2[i]+" "); }
System.out.print("n");
if(arr2.length==1){
System.out.println("已经无法再缩减，程序停止");
break;
}
}while(true);
}
}
排序
-
排序是将多个数据，依指定的顺序进行排列的过程。
分类
（1）内部排序：
指将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法，选择式排序法和插入式排序法）；
（2）外部排序法： 数据量过大，无法加载到内存中，需要借助外部存储进行排序，包括（合并排序法和直接合并排序法）。
冒泡排序法(两两对比)
-
基本思想：通过对待排序序列从后向前（从下标较大的元素开始），一次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前向后移动，就像水底下的气泡一样逐渐向上冒。
-
例：将五个无序 数字 24，69，80，57，13使用冒泡排序法将其排成一个从小到大的有序数列。
public class BubbleSort{
public static void main(String[] args){
int arr[] = {35,99,80,57,13};
int temp = 0;
for(int k = 1;k <= arr.length;k++){
for(int i = 0,j = i+1;j <= (arr.length)-k;i++,j++){
if(arr[i]>arr[j]){
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
for(int i = 0; iarr[j]){
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
i++;
}
}
}
for(int i = 0; i
查找
-
例：有一个数列：王源，王俊凯，易烊千玺，朱一龙，王一博：从键盘中任意输入一个名称，判断数列中是否包含此名称（用顺序查找即可）要求：如果找到了，就提示找到，并给出下标值
import java.util.Scanner;
public class SeqSearch{
public static void main(String[] args){
String arrs[] = {"王源","王俊凯","易烊千玺","朱一龙","王一博"};
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入您想查找的男友名");
String name = myScanner.next();
int index = -1;
//设置的索引值，为了找不到时提醒
for(int i = 0;i < arrs.length;i++){
if(name.equals(arrs[i])){
System.out.println("恭喜您找到了您的老公"+name+"! ! !n"+"下标为"+i);
index++;
break;
}
}
if(index == -1){
System.out.println("Sorry，他还不是你的老公请继续努力");
}
}
}
二维数组
入门案例：
请用二维数组输出如下图形：
000000
001000
020300
000000
public class TwoDimensionalArray01{
public static void main(String[] args){
int arrs[][] = {{0,0,0,0,0,0},{0,0,1,0,0,0},{0,2,0,3,0,0},{0,0,0,0,0,0}};
for(int i = 0;i < arrs.length;i++){
for(int j = 0;j < arrs[i].length;j++){
System.out.print(arrs[i][j]);
}
System.out.print("n");
}
}
}
-
二维数组的第一个【】表示这个数组里有多少给一维数组。第二个【】表示一维数组里的具体元素
例：arrs【4】【5】表示：这个二维数组有4个一维数组，每个一维数组里有5个元素
-
使用方法：
（1）动态初始化：
语法：类型【】【】数组名 = new 类型【大小】【大小】
-
演示：int arrs【】【】 = new int【】【】
-
例：动态创建下面的二维数组，并输出
1
2 2
3 3 3
public class TwoDimensional02{
public static void main(String[] args){
int arr[][] = new int[3][];//创建二维数组，但并没有给一维数组开空间
for(int i = 0; i < arr.length;i++){
arr[i] = new int[i+1];//一定要记得开空间，如果没有开空间，那么arr【i】就是null
for(int j = 0;j < arr[i].length;j++){
arr[i][j] = i + 1;
System.out.print(arr[i][j]);
}
System.out.print("n");
}
}
-
（2）静态初始化（简单）
例：int arr【】【】 = {{1，2，3}，{2，3}，{3，4}}；
-
例题：
int arr【】【】= {{4，6}，{1，4，5，7}，{-2}}遍历该二维数组，并得到和
public class TwoDimensional03{
public static void main(String[] args){
int arr[][] = {{4,6},{1,4,5,7},{-2}};
int sum = 0;
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
sum += arr[i][j];
System.out.print(arr[i][j]+"t");
}
System.out.print("n");
}
System.out.println("该数组的和为"+sum);
}
}
