数组
别人的讲解
数组的概念
数组是一组数据类型相同的数据的组合，将这些数据统一的管理起来
数组是一个引用数据类型,数组内存的类型可以是基本类型，也可以是引用类型
数组的定义（声明）
数据类型[] 数组名字：
int[] x;
char[] y;
boolean[] z;
String[] m;
其他的定义方式：
int x[];
int []x;
数组的赋值（初始化）
静态初始化 有长度 有元素
int[] array = new int[]{10,23,30,40,50};
int[] array = {10,20,30,40,50};
动态初始化 有长度 没有元素（不是真的没有 是保存默认值）
int[] array = new int[5];
整数默认值--0
浮点数默认值--0.0
字符类型默认值--char对应0的字解码 比如 97对应a 65对应A 48对应‘0’
布尔型默认值--false
引用数据默认值--null
访问元素
通过元素在数组的位置index（索引/下标）来访问
索引是有取值范围的【从0开始-数组长度-1】
如果数组的索引超出了上述范围
会出现一个运行异常 ArrayIndexOutOfBoundsException (数组索引超出边界)
数组元素的遍历（轮询）
通过循环的方式访问数组的每一个元素
JDK1.5版本之后 新的特性 增强for循环： forEach
for(自定义的变量（用于接收数组内的每一个元素）: 遍历的数组Array){
}
正常的for
有三个必要条件 index索引 找到某一个位置
可以通过index直接访问数组的某一个位置 存值 取值都可以
增强的for
有两个必要条件 用来取值的变量 用来的遍历的数组 没有index索引
不能存值 只能取值
没有index索引 找不到元素到底是哪一个
练习
用数组来存储1-100之间的奇数
public class Test0 {
public static void main(String[] args){
//静态初始化a、b数组
int[] a = new int[]{1,2,3,4};
int[] b = new int[]{5,6,7,8};
//堆内存的数组空间长度一旦确定 不能再次发生改变。那我们定义一个动态数组器调换元素作用
int[] x = new int[4];
//for循环将a数组中的元素赋值到x数组中，现在x{1,2,3,4}
for (int i=0;i<a.length;i++){
x[i] = a[i];
}
//for循环将b数组中的元素赋值到a数组中，现在a{5,6,7,8}
for (int i=0;i<a.length;i++){
a[i] = b[i];
}
//for循环将x数组中的元素赋值到b数组中，现在b{1,2,3,4}
for (int i=0;i<a.length;i++){
b[i] = x[i];
}
//while循环遍历替换后的a和b中的元素
int z = 0;
while(z<a.length){
System.out.println(a[z]);
System.out.println(b[z]);
z++;
}
}
}
a{1,2,3,4} b{5,6,7,8}内的元素位置对应互换
public class Test1 {
public static void main(String[] args) {
//将数组a{1、2、3、4} b{5、6、7、8}内的元素位置对应互换
//1、每次循环将两个数组中对应位置的元素互换（循环对此，受长度限制）
int[] a = {1,2,3,4};
int[] b = {5,6,7,8};
for(int i = 0;i<a.length;i++) {
int x = a[i];
a[i] = b[i];
b[i] = x;
System.out.println(a[i]);
System.out.println(b[i]);
}
//2、直接交换数组a和b数组的引用地址（不用循环，不受长度限制）
int [] y = a;
a = b;
b = y;
for(int z : a) {
System.out.println(z);
}
for(int z : b) {
System.out.println(z);
}
}
}
a{1,2,3,4,5,6}内的元素位置逆向调换
public class Test2 {
public static void main(String[] args) {
//静态生成一个数组
int[] a = new int[]{1,2,3,4,5,6,7,7,9};
//通过第三个int元素介入，每次循环从外向内进行元素互换
for(int i=0;i<a.length/2;i++) {
int x = a[i];
a[i] = a[(a.length-1)-i];
a[(a.length-1)-i] = x;
}
for(int y:a) {
System.out.println(y);
}
}
}
a{1,2,3,4,5,6}计算数组所有元素的平均值
public class Test3 {
public static void main(String[] args){
//静态定义一组数据
int[] a = new int[]{1,2,3,4,5};
//定义一个数值为0的int类型变量，用于接收a数组内的元素进行相加
int sum = 0;
//while遍历数组a中的元素，进行相加
int i = 0;
while(i<a.length){
sum = sum+a[i];
i++;
}
//打印出平均值
System.out.println(sum/a.length);
}
}
{1,3,5,7,9,0,2,4,6,8}找出最大值和最小值
public class Test4 {
public static void main(String[] args){
/*
* 1、定义一个值为0的int数据类型对象，用来接收a数组的元素
* 2、遍历a数组的元素，没次赋值给int对象
* 3、下一次遍历是判断当前int对象和上一次遍历被赋值的int对象谁更大，
* 如果当前遍历对象更大则进行赋值，更小则进行下一次遍历。
* 4、最小值思路反之
*/
//静态定义一数组
int[] a = new int[]{1,3,5,7,9,0,2,4,6,8};
int MaxNum = 0;
for(int i = 0;i<a.length;i++){
if(a[i]>MaxNum){
MaxNum = a[i];
}
}
int MinNum = 0;
for(int x = 0;x<a.length;x++){
if(a[x]<MinNum){
MinNum = a[x];
}
}
System.out.println("a数组中的最大值是："+MaxNum);
System.out.println("a数组中的最小值是："+MinNum);
}
}
a{1,2,3} b{4,5} 合并两个数组
public class Test5 {
public static void main(String[] args) {
//创建两个数组
int[] a = {1,2,3};
int[] b = {4,5};
//创建一个新数组向内添加内容
int[] NewArray = new int[a.length+b.length];
//将a数组的元素添加进NewArray
for(int i = 0;i<a.length;i++) {
NewArray[i] = a[i];
}
//将b数组的元素添加进NewArray
for(int i = 0;i<b.length;i++) {
NewArray[a.length+i] = b[i];
}
//遍历输出NewArray
for(int x:NewArray) {
System.out.println(x);
}
}
}
{5,4,2,3,1}升序排列
public class Test6 {
public static void main(String[] main) {
int[] a = { 5, 4, 2, 3, 1 };
for (int x = 1; x < 5; x++) {//重复执行升序循环
for (int i = 4; i >= x; i--) {//找出一个最小数进行升序替换
// 如果后面的数比前面的数大，就进行替换
if (a[i] < a[i-1]) {
int change = a[i];
a[i] = a[i-1];
a[i-1] = change;
}
}
}
for (int x : a) {
System.out.println(x);
}
}
}
二维数组
一维数组本质上就是一段连续的内存空间，用于存放多个类型相同的数据。
二维数组本质就是有一堆数组组成的数组，其实就是每个元素为一组数组的数组。
定义格式
格式1：
数据类型[][] 变量名 = mew 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
举例：
int[][] arr =new int[3][2];
定义一个二维数组arr
这个二维数组有3个一维数组，名称为arr[0],arr[1],arr[2]
每一个以一维数组有2个元素，可以通过arr[m][n]来获取元素
格式2：
数据类型[][] 变量名 = new 数据类型[][]{{元素}，{元素}，{元素}}；
数据类型[][] 变量名 = {{元素}，{元素}，{元素}}；
举例：
int[][] arr = {2，9}，{1，2，3}，{4，5}；
数组的初始化
静态初始化
int[][] array = {{1,2},{3,4,5},{6,7,8,9}};
动态初始化
int[][] array = new int[3][2];
array --> {{x,x},{x,x},{x,x}}
练习
求公司年销售额总额
某公司按季度和月份统计的销售数据如下：单位（万元）
第一季度：22，44，66
第二季度:77，55，66
第三季度：60，48，50
第四季度：70，58，66
public class ArrsTest {
public static void main(String[] args) {
//初始化一个二维数组
int[][] arr = {{22,44,66},{77,55,66},{60,48,50},{70,58,66}};
//初始化一个int类型变量，用来接收最后的总额
int x = 0;
//第一个循环用来输出二维数组中有多少个一维数组
for(int i =0;i<arr.length;i++) {
System.out.println("我是第"+(i+1)+"季度");
//第二个循环用来输出每个一维数组，并将值赋给x
for(int j = 0;j<arr[i].length;j++) {
System.out.println(arr[i][j]+"万");
x += arr[i][j];
}
}System.out.println("全年销售总额为："+x+"万");
}
}
我是第1季度
22万
44万
66万
我是第2季度
77万
55万
66万
我是第3季度
60万
48万
50万
我是第4季度
70万
58万
66万
全年销售总额为：682万