文章目录
数组
一维数组
1，一维数组概述和定义格式说明
1.1数组概念
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器来存放数据。通俗的来说：数组是存储 多个变量(元素)的东西(容器)而这多个变量的数据类型要一致
1.2数组定义格式
格式1： 数据类型[] 数组名；
格式2： 数据类型 数组名[];
浅浅的举个例子吧：
int[] a; //定义了一个int类型的数组a；
int arr[]; // 定义了一个int类型的a数组；
2，数组的初始化
2.1首先了解何为数组初始化，为什么要初始化
首先，在Java中的数组必须先初始化,然后才可以使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
2.2初始化又可以分为什么？
动态初始化: 只指定长度，由系统给出初始化值
静态初始化: 给出初始化值，由系统决定长度
注意事项： 这两种方式，只能使用一种，不能进行动静结合
动态初始化：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
浅浅的举个小例子：
int arr[] = new int[3]; // 定义了一个int类型的数组arr，这个数组可以存放3个int类型的值
double[] d = new double[3]; // 定义了一个double类型的数组d，这个数组可以存放3个double类型的值
boolean[] a = new boolean[3]; //定义了一个boolean类型的数组a，这个数组可以存放3个boolean类型的值
静态初始化：
格式： 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式：数据类型[] 数组名 = {元素1,元素2,…};
浅浅的举个小例子：
//静态初始化方式1：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
int[] arr = new int[]{1,2,3};
//静态初始化方式2：数据类型[] 数组名 = {元素1,元素2,…};
int[] arr = {1,2,3};
一维数组案例演示
基础
//定义一个数组，输出数组名称和数组中的元素值，给数组赋值，再次输出数组名称和数组中的元素值
int[] arr = new int[3];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
System.out.println(arr); //[I@1b6d3586
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
一维数组求最大最小值
//数组获取最值(获取数组中的最大值或者最小值)
int []a={10,20,3,200,4};
int max=a[0];
int min=a[0];
for (int i = 0; i < a.length; i++) {
if(max<a[i]){
max=a[i];
}
if(min>a[i]){
min=a[i];
}
}
System.out.println("max="+max);
System.out.println("min="+min);
}
数组反转
//数组元素反转
int []a={11, 32,55, 47,79,23};
方式一：
//首尾交换 倒置数组
for (int i = 0; i < a.length / 2; i++) {
int t=a[i];
a[i]=a[a.length-1-i];
a[a.length-1-i]=t;
}
System.out.println(Arrays.toString(a)); //Arrays.toString()调用方法输出数组
}
/*
方式二：
for(int i = 0,j = a.length- 1;i<j;i++,j--){
String temp = a[i];
a[i] = a[j];
a[j] = temp;
}
*/
冒泡排序
int [] arr = new int [] {34,6,-5,14,-56,41};
System.out.print("原始的数组：");
for(int i = 0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
//或者
//System.out.println(Arrays.toString(a));
System.out.println();
System.out.print("排序后的数组：");
//冒泡排序
//for (int i = 0;i<arr.length;i++){
for (int i = 1;i<arr.length;i++){
//for(int j = 0;j<arr.length - i -1;j++){
for(int j = 0;j<arr.length - i;j++){
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(a));
二分法查找
/*二分法查找
前提：所有要查找的数据必须有序，故 可以先进行排序
* */
int[] arr2 = new int []{-98,-47,-12,12,34,45,89};
int d= 34;
boolean flag = true;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末尾索引
while(head <= end){
int m = (head +end) / 2;
if(dest1 == arr2[m]){
System.out.println("找到了指定的元素，位置为："+m);
flag = false;
break;
}else if (arr2[m]>d){
end = m -1;
}else{
head = m + 1;
}
}
二维数组
1，二维数组概述和定义格式说明
1.1二维数组的概述：
二维数组其实就是每一个元素为一维数组的数组。
用个通俗的理解方法：就好比我们的学校中的我们班，我们班中有很多学生我们学生就好比数组中的数据元 素，我们的班级就好比一个一维数组，然而这样的班有很多个。要将这样的班也用一个数组来存储，就是二 维数组。
1.2二维数组的定义格式：
格式1：
数据类型[][]变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组 必须写上
n表示每一个一维数组的元素个数 可选写或不写均可
格式2：
数据类型[] 数组名[] = new 数据类型[m][n]; 不推荐使用
格式3：
数据类型 数组名[][] = new 数据类型[m][n];
浅浅的举个小例子：
int[][] arr = new int[3][2];
//定义了一个二维数组arr
//这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2] 表示地址
//每个一维数组有2个元素，可以通过arr[m][n]来获取
//表示获取第m+1个一维数组的第n+1个元素
注意：
int[] x,y[];
int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
x=new int[3];
y=new int[3][];
若n不写
数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举个小例子来说吧
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[1];
2,二维数组初始化：
二维数组静态初始化
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}…};
简化版:
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
浅浅的举个小例子：
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{5,6},{7}};
二维数组案例演示
求和
/*
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22, 66, 44
第二季度：77, 33, 88
第三季度：25, 45, 65
第四季度：11, 66, 99
*/
//我们可以使用二维数组来存储
//方法1，使用动态初始化
Scanner sc = new Scanner(System.in);
int[][] a = new int[4][3];
int sum = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.println("请录入第" + (i + 1) + "季度" + (j + 1) + "个数据:");
a[i][j] = sc.nextInt();
}
}
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
sum += a[i][j];
}
}
System.out.println("销售和："+sum);
//方法2，使用用静态初始化
int[][] a2 = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
sum=0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
sum += a[i][j];
}
}
System.out.println("销售和："+sum);
}
数组图形杨辉三角
/* B:
需求：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
先找规律：
1.每一行的首尾元素都是1
2. 从第三行，第二列开始，中间的元素等于他上一行的前一列和上一行的本列元素之和
步骤：
A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
这个n的数据来自于键盘录入。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值
从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
D:遍历这个二维数组。
*/
//方法一
Scanner sc=new Scanner(System.in);
int n = sc.nextInt();
int [][]a=new int[n][];
for (int i = 0; i < a.length; i++) {
int []b=new int[i+1];
b[0]=1;
b[b.length-1]=1;
if((i+1)>2){
for (int j=1;j<i;j++) {
b[j] = a[i - 1][j-1]+a[i-1][j];
}
}
a[i]=b;
}
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j]+" ");
}
System.out.println();
}
//方法二
Scanner sc=new Scanner(System.in);
int n = sc.nextInt();
int [][]a=new int[n][n];
for (int i = 0; i < a.length; i++) {
a[i][0]=1;
a[i][i]=1;
for (int j = 0; j < a[i].length; j++) {
if(i>=2 && j>=1) {
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
}
}
}
//输出图形
for (int i = 0; i < a.length; i++) {
for (int j = 0; j <= i; j++) {
System.out.print(a[i][j]+" ");
}
System.out.println();
}
650
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
