javaDay8_数组

数组：一组 数据，复数数据，

数组也是存储数据，存储的是多个相同类型数据

对象是复合型的数据，存储是一个具体事物的信息

数组存储的是多个相同类型事物的信息

例如： 一个人  and  一个班

    一个人 —— 对象

一个班的人呢—— 一堆对象——对象数据

数组的写法：

1.创空数组：数组内部是空的

泛型【对象/引用，基本类型 ….只要能表示数据的】[ ]【数组】名字 = new泛型[长度【int】]

例如： 创建int类型的数组  长度为 10

int[] is =new int[10];

长度：规定数组中可以存放 多少个泛型类型的数据，因为数组是有长度限制，长度必须声明

泛型：规定该数组是什么类型，规定了数组中可以方法什么类型的值

数组的下标：从0开始，为数组中每一个元素位置进行标记，不重复

下标  = 长度（容量） - 1

元素：每一个元素 代表了数组中存储的某一个具体的数据

通过下标操作元素位置：

    泛型类型  名字 =   数组名[下标] ；获取数组元素位数据

数组名[下标]=值；      赋值数组某个下标位的内容

public static void main(String[] args) {

    //10个长度的int类型的数组 is

int[] is =new int[10];

//5号元素位赋值 = 第6个数据   因为 下标从0开始  = 长度-1

is[5]=10;

int i =is[5];

System.out.println(i);

}

2．创建非空数组：

泛型[ ] 数组名字 ={数据，数据，数据……. }

该方式相当于把数据直接放进数组中

数组长度决定于写了多少个数据，多个数据之间，分隔

例如：存一班的人

public class Test {

public static void main(String[] args) {

   people p=new people();

   

   //空的people类型的数组 长度20

   people[] ps =new people[20];

   

   //非空的people类型的 长度3的数组

 people[] ps2 ={new people(),new people(),new people()};

   

}

}

class people{

}

数组的迭代遍历：

例如 ： int[] I ={10,20,30,40,50};

要求获取全部的元素位的数据

I[0]

I[1]

…

I[3]

 重复I[下标]，代码重复利用循环

下标 0——长度-1

For(int x =0；x<4;x++){

    I[x]

}

.length:获取数组的长度

数组名.length

遍历方式1：

For(int i=0 ；i<数组名.length;i++){

  泛型  名 = 数组名[i]；

}

int i1=10;

int i2=50;

int i3=30;

int[] is ={i1,i2,i3};

for(int i=0;i<is.length;i++){

System.out.println(is[i]);

}

遍历方式2： foreach循环，增强for循环

For(数组元素的泛型 名字：数组名){

}

原理：每一圈循环会获取一个元素，并将该元素赋值给: 前面的声明

//书写方法

for (int i : is) {

System.out.println(i);

}

//灵活

    for (int i = is.length-1; i >=0; i--) {

int j = is[i];

System.out.println(j);

    }

相比普通循环，增强循环foreach 书写简介，但是只能从下标0开始全部遍历出来，缺少灵活

普通循环遍历，结构书写繁琐，灵活多变

练习： 实体类 CarPojo ，私有属性，setget方法，构造方法，toString

属性：品牌，售价，油耗

测试类，

造车方法，随意输入订单数目，生成对应数目的汽车，并返回

Main 调用造车

多维数组：数组是无限维的

泛型[][]…  数组名字  = new 泛型[最外层元素长度][次层元素长度]…

例如：

int[][] iss =new int[10][10];//二维的数组 外层10元素，内10元素

泛型[][]… 数组名字 = {

     { …  },

     { …  },

     …

}

例如：

int[][] iss2={    

   {1,2,3,4},

   {1,2,3,4},

   {1,2,3,4},

 };//外3元素，内4元素的二维数组

遍历多维数组：

For(外层数组){

   //得到内层数组

   For(内层数组){

      …

      最后得到数据

}

}

例如：

int[][] iss2={    

   {1,2,3,4},

   {1,2,3,4},

   {1,2,3,4},

   };

 for (int i = 0; i < iss2.length; i++) {

int[] js = iss2[i];

for (int j = 0; j < js [i].length; j++) {

int io = js[j];

System.out.println(js[j]);

}

}

冒泡排序：该算法给多组数据进行排序 — 错位比较

例如：

int[] is = { 10, 2, 3, 11, 9, 15, 13, 7 };

要按照从小到大依次排序数组的内部元素位置

想法：

1. 错位比较，即前一个值与后一个值比较大小
2. 要与全部的值进行比较最后确定位置

int[] is = { 10, 2, 3, 11, 9, 15, 13, 7 };

// 依次比

for (int y = 0; y < is.length - 1; y++) {

// 错位比较

for (int i = 0; i < is.length - 1; i++) {

if (is[i] > is[i + 1]) {

// 从小到达 ;前比后大—— 前值放后位置

int t = is[i];// 提前记录防止值丢失

is[i] = is[i + 1];// 同步前后值

is[i + 1] = t;// 修改后值

}

}

}

for (int i : is) {

System.out.println(i);

}

练习：

1.

Double[] ds ={ 1 ,6,0.5,6.1,9,5,4,3,10,2}

按照从大到小的顺序排列其中元素并打印

2.int[][] iss={

{8,4,6},

{3,1,7},

{5,10,11},

}

将每层中的元素按照从小到大排序