数组很重要，因为接下来更新完数组就该是面向对象三大特性（封装、继承、多态）其中我认为继承和多态有一丢丢的难。请小伙伴们继续努力。
一、数组的概念
数组是一个连续的空间，是一个容器，可以存储多个同类型数据的值。
数组容器在存储数据的时候，需要隐式转换来考虑。自动提升。
（1）int 类型的数组容器（byte、short、int）
（2）double类型的数组容器（byte、short、int、long、float、double）boolean存不了。
二、数组的定义
声明数组：数据类型 [ ] 数组名 =new 数据类型 [ ]；
例如：int [] a=new int [5] ；
完整格式：数据类型 [] 数组名 = new 数据类型 [] {元素1，元素2，元素3.......};
int [] array = new int [] {11,22,33};（[]中不能写长度，长度取决于赋值的个数。）
简写格式：数据类型 [] 数组名 ={元素1，元素2，元素3......}
int [] arry ={元素1，元素2，元素3,}
初始化：就是在内存中，维数组容器开辟空间，并将di数据存入容器的过程
格式：数组名[索引]；
索引：也叫作下表，角标。从0开始，不中断。
int [] arr = {1,2,3,4} ，int number =arr[0] 这就是取的是第一个值1。
System.out.printin（number）或者 System.out.printin（arr[0]）
取值：数组名[下标] 例如：a[0] 表示取下标为0的元素值，即10
赋值：数组名[下标] = 值 例如：a[1] = 666表示给下标为1的元素赋值为666，覆盖原值
若想通过 System.out.printin（arry）直接打印 数组会直接显示 I@_________ 一串东西，其中I代
表的是数据类型@代表一个间接符号，固定格式而已。_______（这就是数组的地址值）
直接打印不会出现数据元素，而是直接出数组的地址值。
习题
定义一个长度为5的数组，并为每个数组进行元素赋值，最后再去出每个元素的值进行打印输出。
public class Demo02 {
public static void main(String[] args) {
定义长度为5的数组
int [] arr = new int[5];
通过下标为数组元素赋值
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
打印元素的值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
}
}三、数组的遍历
数组遍历：将数组中所有内容取出来，取出来之后可以（打印，求和，判断）注意：遍历指的是去除数据的过程，不要局限理解，遍历就是打印！
循环的简洁写法 4.for i=for (int i = 0; i < 4; i++)，在Java中关于数组的长度属性：length
调用方法：数组名.length。 for (int i = 0; i1< arr.length; i++)
在IDEA中有一个快捷键，数组名.for i 就可以了 就会自动生成 for (int i = 0; i1< arr.length; i++)
循环的案例
public class Demo03 {
public static void main(String[] args) {
定义长度为5的数组
int [] arr = new int[5];
通过下标为数组元素赋值
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
遍历数组元素
for (int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}其中就是 ，从0开始是下标，然后小于这个数组的长度，而这种长度是用数组.ength（也就是小于数组长度）。
习题1
动态打印数组 定义一个长度为5 的数组，分别存入5个同学的身高（小数类型）
扫描器
Scanner sc=new Scanner(System.in);
double[] arry=new double[5];
arry.length 是一个数组的长度值
for(int i=0;i<arry.length;i++)
{
System.out.println("请输入身高");
每一次循环将数据传入数组中
arry[i] = sc.nextDouble();
}
for(int i=0;i<arry.length;i++)
{
System.out.println(arry[i]);
}
习题2
定义一个数组，其中数组存储的元素是1，2，3，4，5并求和
public static void main(String[] args) {
int sum=0;
int arry []={1,2,3,4,5};
for (int i = 0; i < arry.length; i++)
{
System.out.println(arry[i]);
sum+=arry[i];
}
System.out.println(sum);
}习题3
定义一个数组，存储1,2,3,4,5,6,7,8,9,10
遍历数组的每一个元素，统计数组里面有多少个被3整除的数字
int [] arry={1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < arry.length; i++) {
if(arry[i]%3==0)
{
System.out.println(arry[i]);
}
}四、数组动态初始化
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
格式：数据类型 [] 数组名 =new 数据类型 [数组长度]； int [] arr =new int [3];
数组默认初始化值的规律
只要是整数类型：默认初始化值: 0
小数类型：默认初始化值：0.0
字符类型：默认初始化值：'\u0000’空格
布尔类型：默认初始值：false
引用数据类型：默认初始化值：null
五、数组的扩容
想一想如果数组的长度是固定的，是不是对数字具有局限性了，这就有了扩容的思想。
扩容的思想：
（1）首先创建一个数组大于原数组的长度。
（2）将原数组的长度复制到新数组中
复制实现的方式
（1）循环将原数组中所有元素逐一赋值给新数组。
（2）Sysrtem.array.copy（原数组，原数组下标，放入那个数组，新数组的起始位，长度）
（3）java.util.copyOf（原数组，新长度）；//返回带有原值的新数组。这个其实是这么用的
类型 [] 类型=Arrays.copyOf （原数组，新数组长度）
打印数组的方法
System.out.println（Arrays.toString （数组名））
public class Demo01 {
public static void main(String[] args) {
int [] a = {1,2,3,4,5};
int [] b = new int[10];
自定义复制
for (int i=0;i<a.length;i++){
b[i] = a[i];
}
System.out.println(Arrays.toString(b));
System.out.println("===============================");
使用系统方法复制
System.arraycopy(a,0,b,0,5);
System.out.println(Arrays.toString(b));
System.out.println("===============================");
工具类方法复制
int[] c = Arrays.copyOf(a, 10);
System.out.println(Arrays.toString(c));
}
}六、数组做方法参数
引用传递
public class Demo04 {
public static void main(String[] args) {
int i = 10;
count(i);
System.out.println(i);
}
//基本类型做参数
public static void count(int i){
i++;
System.out.println(i);
}
}引用传递
引用传递
public class Demo04 {
public static void main(String[] args) {
int i = 10;
count(i);
System.out.println(i);
}
//基本类型做参数
public static void count(int i){
i++;
System.out.println(i);
}
}
public class Demo05 {
public static void main(String[] args) {
int []arr = {1,1,1,1};
count(arr);
System.out.println("实参："+Arrays.toString(arr));
}
//基本类型做参数
public static void count(int []arr){
for (int i=0;i<arr.length;i++){
arr[i]++;
}
System.out.println("形参："+Arrays.toString(arr));
}
}七、可边长参数
可变长参数
概念：可以接收多个同类型实参，个数不限，使用方式与数组相同。
格式：语法：数据类型...形参名 必须定义在形参列表的最后，且只能有一个
public static void temp（String name，char sex，String...hobby）{
System.out.ptintln（name）;
System.out.ptintln（sex）;
//System.out.println（hobby）；
for（int i=0; i<hooby.length;i++）
{
System.out.println（hobby[i]）；
}
}八、数组的排序
public class Demo08 {
public static void main(String[] args) {
int []arr = {14,56,9,34,28};
第一轮
for (int i =0;i<arr.length-1;i++){
int temp;
if (arr[i] > arr[i+1] ){
temp = arr[i];
arr[i] = arr [i+1];
arr[i+1] = temp;
}
}
System.out.println(Arrays.toString(arr));
第二轮
for (int i =0;i<arr.length-2;i++){
int temp;
if (arr[i] > arr[i+1] ){
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println(Arrays.toString(arr));
第三轮
for (int i =0;i<arr.length-3;i++){
int temp;
if (arr[i] > arr[i+1] ){
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println(Arrays.toString(arr));
第四轮
for (int i =0;i<arr.length-4;i++){
int temp;
if (arr[i] > arr[i+1] ){
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
这是双重循环的方式比那种单层循环的简单不少。
for (int j = 0;j<arr.length-1;j++){
for (int i =0;i<arr.length-1-i;i++){
int temp;
if (arr[i] > arr[i+1] ){
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}package com.qianfeng;
import java.util.Arrays;
public class Demo10 {
public static void main(String[] args) {
int []arr = {14,56,9,34,28};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
