package demo01;
/*
数组：是一种容器，可以同时存放多个数据值
1.数组是一种引用数据类型
2.数组当中的多个数据，类型必须统一
3.数组的长度在程序运行期间不可改变
数组的初始化：在内存中创建一个数组，并且向其中赋予一些默认值
两种常见的初始化方式
1.动态初始化（指定长度）
2.静态初始化（指定内容）
动态初始化数组的格式：
数据类型[] 数组名称 = 数据类型[数组长度]；
解析含义：
左侧数据类型：就是数组当中保存的数据，全都是统一的什么类型
左侧的中括号：代表我是一个数组
左侧数组的名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字
*/
public class Demo01Array {
public static void main(String[] args) {
//创建一个数组，里面可以存放300个int数据
//格式，数据类型[] 数组名称 = new 数据类型[数组长度]；
int[] arrayA = new int[300];
//创建一格数组，能存放10个double类型的数据
double[] arrayB = new double[10];
//创建一格数组，能存放5个字符串
String[] arratC = new String[5];
}
}
package demo01;
/*
动态初始化：（指定长度）在创建数组的时候，直接指定数组当中的数据元素个数
静态初始化：（指定内容）在创建数组的时候，不直接指定数组个数多少，而是直接将具体的数据内容进行指定
静态初始化基本格式：
数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，....}；
注意事项
虽然静态初始化直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度
*/
public class Demo02Array {
public static void main(String[] args) {
//直接创建一个数组，里面装的全部是int数字，具体为5、25、35
int[] arrayA = new int[] {5,15,25};
//创建一格数组，用来装字符串"Hello"、"world"、"Java"
String[] arraty = new String[] {"Hello","Woeld","Java"};
}
}
package demo01;
/*
使用静态初始化数组的时候，格式还可以省略以下
标准格式：
数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，....}；
省略格式：
数据类型[] 数组名称 = {元素1，元素2，....}；
注意事项：
1.静态初始化没有直接指定长度，但是仍然会自动推算得到长度
2.静态初始化标准格式可以拆分成为两个步骤
3.动态初始化也可以拆分成为两个步骤
4.静态初始化一旦使用省略格式，就不能拆分成为两个步骤了
使用建议：
如果不确定数组当中的具体内容，用动态初始化，否则，已经确定了具体的内容，用静态舒适化
*/
public class Demo03Array {
public static void main(String[] args) {
//省略格式的静态初始化
int[] arrayA = {10, 20, 30};
//静态初始化的标准格式，可以拆分成为两个步骤
int[] arrayB;
arrayB =new int[] {11,21,31};
//动态初始化也可以拆分成为两个步骤
int[] arrayC;
arrayC = new int[5];
//静态初始化的省略格式，不能拆分成为两个步骤
// int arrayD;
// arrayD = {10,20,30};
}
}
package demo01;
/*
直接打印数组名称，得到的是数组对应的，内存地址哈希值
二进制：01
十进制：0123456789
16进制“0123456789abcdef
访问数据元素的格式，数组名称{索引值}
索引值：就是一个int数字，代表数组当中元素的编号
【注意】：索引值从0开始，一直到“数组长度-1”为止
*/
public class Demo04ArratUse {
public static void main(String[] args) {
//静态初始化的省略格式
int[] array = {10,20,30};
System.out.println(array);//[I@3f99bd52
//直接打印数组当中的元素
System.out.println(array[0]);//10
System.out.println(array[1]);//20
System.out.println(array[2]);//30
System.out.println("============");
//也可以将数组当中的某一个单个元素，赋值交给变量
int num = array[1];
System.out.println(num);//20
}
}
package demo01;
/*
使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值，规则如下
如果是整数类型，那么默认为0
如果是浮点类型，那么默认为0.0
如果是字符串类型，那么默认为'\u0000'
如果是布尔类型，那么默认为false
如果是引用类型，那么默认为null
注意事项：
静态初始化其实也有默认值得过程，只不过系统自动吗上将默认值替换成为了大括号当中的具体数据
*/
public class Demo05ArrayUse {
public static void main(String[] args) {
//动态初始化一个数组
int[] array = new int[3];
System.out.println(array);//内存地址值
System.out.println(array[0]);//0
System.out.println(array[1]);//0
System.out.println(array[2]);//0
System.out.println("============");
//将数据123赋值交给数组array当中的1号元素
array[1] = 123;
System.out.println(array[0]);//0
System.out.println(array[1]);//123
System.out.println(array[2]);//0
}
}
package demo02;
public class Demo02ArraySame {
public static void main(String[] args) {
int[] arrayA = new int[3];//动态初始化
System.out.println(arrayA);//地址值
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//0
System.out.println(arrayA[2]);//0
System.out.println("===========");
//改变数组当中元素的内容
arrayA[1] = 10;
arrayA[2] = 20;
System.out.println(arrayA);//地址值
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//10
System.out.println(arrayA[2]);//20
System.out.println("===========");
//将arrayA数组的地址值，赋值给arrayB数组
int[] arrayB = arrayA;//动态初始化
System.out.println(arrayB);//地址值
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//0
System.out.println(arrayB[2]);//0
System.out.println("===========");
//改变数组当中元素的内容
arrayB[1] = 100;
arrayB[2] = 200;
System.out.println(arrayB);//地址值
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//10
System.out.println(arrayB[2]);//20
System.out.println("===========");
}
}
package demo03;
/*
数组索引编号从0开始，一直到“数组的长度-1”为止
如果访问数组元素的时候，所以你编号并不存在，那么将会发生数组索引越界异常
原因：索引编号写错了
解决：修改成为存在的正确的索引编号
*/
public class Demo01ArrayIndex {
public static void main(String[] args) {
int[] array = {15,25,35};
System.out.println(array[0]);//15
System.out.println(array[1]);//25
System.out.println(array[2]);//35
//错误写法
//并不存在3号元素，所以发生异常
System.out.println(array[3]);
}
}
package demo03;
/*
所有的引用类型变量，都可以赋值为一个null值，但是代表其中什么都没有
数组必须进行new初始化才能使用其中的元素
如果只是赋值了一个null，没有进行new创建，那么江湖发生空指针异常
原因：忘了new
解决：补上new
*/
public class Demo02ArrayNull {
public static void main(String[] args) {
int[] array = null;
// array = new int[3];
System.out.println(array[0]);
}
}
获取数组的长度
package demo03;
/*
如何获取数组的长度，格式：
数组名称.Length
这将会得到一个int数字，代表数组的长度
数组一旦创建，程序运行期间，长度不可改变
*/
public class Demo03ArrayLength {
public static void main(String[] args) {
int[] arrayA = new int[3];
int[] arrayB = {10,20,30,3,5,6,7,8,8,65,4,44,6,10};
int len = arrayB.length;
System.out.println("arrayB数组的长度是：" + len);
System.out.println("============");
int[] arrayC = new int[3];
System.out.println(arrayC.length);//3
arrayC = new int[5];
System.out.println(arrayC.length);//5
}
}
数组的遍历
package demo03;
/*
遍历数组，说的就是对数组当中的每一个元素进行逐一、挨个处理，默认方式就是打印输出
*/
public class Demo04Array {
public static void main(String[] args) {
int[] array = {15,25,30,40,50,60,75};
//首先使用原始方式
System.out.println(array[0]);//15
System.out.println(array[1]);//25
System.out.println(array[2]);//30
System.out.println(array[3]);//40
System.out.println(array[4]);//50
System.out.println(array[5]);//60
System.out.println("=============");
//使用循环，次数其实就是数组的长度
for (int i = 0; i < 6; i ++){
System.out.println(array[i]);
}
System.out.println("=============");
// int len = array.length;
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
最大值
package demo03;
public class Demo05ArrayMax {
public static void main(String[] args) {
int[] array = {5,15,30,20,1000};
int max = array[0];//比武擂台
for (int i = 1; i < array.length; i ++){
//如果当前元素比max更大，则换人
if (array[i] > max){
max = array[i];
}
}
//谁最后最厉害，就能在max中留下战斗值
System.out.println("最大值：" + max);
}
}
最小值
package demo03;
public class Demo06ArrayMin {
public static void main(String[] args) {
int[] array = {5,15,30,20,-20,1000};
int min = array[0];//比武擂台
for (int i = 1; i < array.length; i ++){
//如果当前元素比min更小，则换人
if (array[i] < min){
min = array[i];
}
}
System.out.println("最小值：" + min);
}
}
package demo04;
/*
数组可以作为方法的参数
当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值
*/
public class Demo01ArrayParam {
public static void main(String[] args) {
int[] array = {10,20,30,40,50};
System.out.println(array);//地址值
printArray(array);//传递进去的就是array当中的地址值
System.out.println("=======AAA=======");
printArray(array);
System.out.println("=======BBB=======");
printArray(array);
}
/*
三要素
返回值类型：只是进行打印而已，不需要进行计算，也没有结果，用void
方法名称：printArray
参数列表：必须给我数组，我才能打印其中的元素 int[] array
*/
public static void printArray(int[] array){
System.out.println("printArray方法受到的参数是：");
System.out.println(array);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
package demo04;
/*
一个方法可以有0、1多个参数；但是只能有0或者1个返回值，不能有多个返回值
如果希望一个方法当中产生个了多个数据进行返回，怎么办
解决方案，使用一个数组作为返回值即可
数组作为方法的参数，传递进去的其实是数组的地址值
数组作为方法的返回值，返回的其实也是数组的地址值
*/
public class Demo02ArrayReturn {
public static void main(String[] args) {
int[] result = calculate(10,20,30);
System.out.println("main方法接受到的返回值数组是：");
System.out.println(result);//地址值
System.out.println("总和：" + result[0]);
System.out.println("平均数：" + result[1]);
}
public static int[] calculate(int a, int b,int c){
int sum = a + b + c;//总和
int avg = sum / 3;//平均数
//两个结果都希望进行返回
//需要一个数组，也就是一个塑料兜，数组可以保存多个结果
// int[] array = new int[2];
// array[0] = sum;//总数
// array[1] = avg;//平均数
int[] array = {sum , avg};
System.out.println("calculate方法内部数组是：");
System.out.println(array);
return array;
}
}
版权声明：本文为carrotluotian原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。