一、数组的原理和特点；
数组：一组能够存储相同数据类型的变量的集合。
当我们有一组相同类型的数据需要存储，如果此时使用单个变量，我们需要定义N个变量，这样做的话会非常繁琐且不利于后期代码的维护。
特点：
1、数组是可以保存一组相同数据类型的一种数据结构
2、定义一个数组必须有固定的长度，且不能修改长度
3、数组拥有边界检查，尝试获取不在数组范围内的值时，会出现数组下标越界异常(ArrayindexOutOfBoundsException)
4、数组是引用类型，会存储在堆内存中。
5、对象数组和基本数据类型数组在使用上是相同的，区别是对象数组保存的是引用，基本类型的数组是保存基本类型的值。
二、动态数组的概念；
动态数组是指一个数组的长度可以动态进行扩充，目的是在数组元素存储满后可以继续存储，已达到“无限”长度。
PS：问题；前面数组特点里提到过，数组在定义时就必须固定长度，且不能修改长度，这显然与动态数组相违背。
解决方法；
1、重新创建一个数组，长度在原数组基础上扩容，放弃原数组
2、把原数组中的元素复制到新数组。
三、手动实现动态数组方法；
具体步骤如下；
1、在添加元素时判断数组是否有空余空间；
2、如果有，则添加元素；
3、反之，跳转到下一步；
4、确定新数组的扩充算法；
5、创建新数组根据扩容后的长度；
6、把原数组中的数据复制到新数组中。
(如图所示)
删除元素；
由于数组是线性数据存储结构，通常需要确保元素的连续性，所以在被删除的元素非数组末尾时，我们需要把被删除元素之后的元素依次向前移动一位，以确保在末尾留出空余位置，这样也便于添加新元素时总是在末尾，查询遍历时也避免空指针异常。
四、动态数组的重要性；
1、动态数组变相解决了数组固定长度带来的问题；
2、数组是存取效率最高的数据结构；
3、动态数组如果频繁扩充必然带来性能下降，产生垃圾数组对象；
4、数组不适是做 删除插入 等操作，适合 添加、 查找、 遍历；
5、动态数组的实现原理被使用在ArrayList、Vector的集合中
6、面试题  ‘手动实现ArrayList类’
动态数组的 应用
Demo:模拟小鸡管理系统(增删改查)
import java.util.Arrays;
public class MyArraysList {
public static void main(String[] args) {
MyArraysLists ma=new MyArraysLists(5);
//添加操作
ma.add(new Chicken(1,12,"小白"));
ma.add(new Chicken(4,10,"小红"));
ma.add(new Chicken(6,14,"小蓝"));
ma.add(new Chicken(2,18,"小紫"));
ma.add(new Chicken(5,8,"小黑"));
ma.add(new Chicken(3,16,"小绿"));
System.out.println("==============添加完毕==============");
//输出所有信息
ma.printAll();
System.out.println("当前对象数组的长度为："+ma.length());
System.out.println("==============删除==============");
ma.delete(4);
ma.printAll();
System.out.println("==============修改==============");
ma.update(new Chicken(2,3,"小宝"));
ma.printAll();
System.out.println("==============查找==============");
Chicken c = ma.find(2);
c.print();
}
}
//管理对象的类
class MyArraysLists{
//需要管理的数组
private Chicken[] cs=null;
//对象数组中元素的个数
private int count = 0;
public MyArraysLists(int size) {
if(size>0) {
cs = new Chicken[size];
}else {
cs = new Chicken[5];
}
}
//表示返回数组长度
public int length() {
return cs.length;
}
//数组中有多少个元素
public int size(){
return count;
}
//添加管理
public void add(Chicken c) {
if(count>=cs.length) {//判断，数组满载则需要扩充
//两种扩充方法
//1、扩充原数组大小的一半(cs.length*3/2+1);2、扩充原数组大小的一倍(cs.length*2)
int newLen = cs.length*2;
cs=Arrays.copyOf(cs, newLen);
}
cs[count]=c;//添加元素
count++;
}
//查找管理
public Chicken find(int id) {
for(int i=0;i
if(cs[i].getId()==id) {
return cs[i];
}
}
return null;
}
//删除管理
//1、先查到要删除的元素(确定要删除的元素)
//2、依次把要删除元素的后一个元素往前移动(覆盖)
//3、把最后一个元素设置为null
public void delete(int id) {
for(int i=0;i
//循环遍历，找到了对象，把该对象之后的对象向前移动一位
if(cs[i].getId()==id) {
for(int j=i;j
cs[j]=cs[j+1];
}
cs[count-1]=null;//把最后一个对象赋值为空
count--;//下标减减
break;//跳出循环
}
}
}
//更新管理
//修改元素(Chicken(id,age,name),id是作为要修改的对象的id，用于作为条件,
//age,name是作为新的值)
public void update(Chicken c) {
Chicken temp=find(c.getId());
if(temp!=null) {
temp.setName(c.getName());
temp.setAge(c.getAge());
}
}
//输出信息
public void printAll() {
for(int i=0;i
cs[i].print();
}
}
}
//用来测试的对象(小鸡类)
class Chicken{
private int id;//编号
private int age;//年龄
private String name;//名字
public Chicken(int id, int age, String name) {
super();
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void print() {
System.out.println("ID="+id+",age="+age+",name="+name);
}
}

数组
数组的基本用法
1、什么是数组
2、数组的定义
2.1创建数组：
2.2类型所对应的“0”值
3、数组的使用
3.1获取长度，访问元素
3.2 下标越界问题
3.3 遍历数组
for循环遍历
for-each遍历数组
两种遍历的比较
4、二维数组
不同角度理解：
不规则使用：
二维数组的遍历：
5、数组的练习：

数组的基本用法
1、什么是数组
数组的本质上，就是让我们能“批量”创建相同类型的变量。即：相同类型的集合。
注意:在Java中，数组中包含的变量必须是相同类型。
2、数组的定义
2.1创建数组：
//动态初始化

数据类型[ ] 数组名称 = new 数据类型 [ ]  {  初始化数据  }；
int [] arr = new int [] {1,2,3,4,5};

//静态初始化

数据类型[ ] 数组名称 = {  初始化数据  }；
int [] arr ={1,2,3,4,5};

还有一种：

数据类型[ ] 数组名称 = new 数据类型 [ 数组长度 ];

这种数组，里面都是类型所对应的==“0”值==
int [] arr = new int [5] ;

2.2类型所对应的“0”值
在没有规定的情况下：




类型
“0”值




byte/short/int
0


long
0L


float
0.0F


double
0.0


boolean
false


char
0x0000对应的字符


引用类型
null


3、数组的使用
3.1获取长度，访问元素
我们通常使用 数组名 . length 获取数组的长度

使用 [ ] 下标访问符，获取数组中的元素。

Java中，数组下标，从0开始。
public class Demo1 {

    public static void main(String[] args) {

        int[] arr = {1, 2, 3, 4, 5};

        int a = arr.length;
        System.out.println(a);//数组的长度
        System.out.println(arr[0]);//打印0号下标数据
    }
}



3.2 下标越界问题
下标的访问操作的范围是 [0 , length-1],如果超过这个范围，就会出现下标越界异常。
public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(arr[5]);//访问5号下标，可是5号下标并没有
    }


这里，访问下标越界。

抛出了：Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException异常。当我们使用数组的时候，一定要谨防下标越界。
3.3 遍历数组
遍历数组指的是，将数组中的每个元素都访问一遍，不重不漏，通常需要使用循环。
for循环遍历
public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
       
    }


for-each遍历数组
for-each是for循环的另一种使用方式，能够快捷方便的完成对数组的遍历，避免循环条件的写错。

for-each的语法格式

for（数组类型对应的类型 ： 数组名）{…};
public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};     
        for (int x : arr) {
            System.out.print(x + " ");
        }
    }


两种遍历的比较
如果访问全部数组，for-each更加方便快捷，避免了循环条件的写错等…

但是如果只访问部分区间，那么for循环更加适合。

两种遍历各有优势，在不同情况下使用。
4、二维数组
二维数组的本质就是一维数组，只不过每个元素又是一个一维数组。
基本语法：

数据类型[][] 数组名称 = new 数据类型 [行数] [列数] {初始化数据}；

数据类型[][] 数组名称 =  {初始化数据}；
int [] [] arr = { { 1 , 2 , 3 } , { 4 , 5 , 6 } } ;

二维数组的用法与一维数组基本类似，在这里就不过多的赘述了。同理还存在三维数组，四维数组…
不同角度理解：
一维数组就像是定义了一个引用，将引用指向这个对象（数组）。



而在二维数组中，就像是先定义一个arr的引用，指向一个int[]的数组，数组里面存放的是引用，里面的引用指向一个一维数组：


不规则使用：
注意：
Java的数组中，还存在着不规则结构，

在C语言中，数组的行是可以自动推导的，列必须指定。

但是在Java中，列可以自动推导，但行必须指定。

例如：
		int[][] arr = new int[2][];
        arr[0] = new int[]{1, 2, 3};
        arr[1] = new int[]{4, 5, 6};

二维数组的遍历：
对于二维数组的遍历：

1、通过调用Arrays.toString(),对一维数组的打印，打印二维数组：
import java.util.Arrays;
public class Demo1 {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3,4}, {4, 5, 6}, {7, 8, 9}};
        print(a);
    }

    private static void print(int[][] a) {
        for (int[] ints : a) {
            System.out.println(Arrays.toString(ints));
        }
    }
}

2、调用deepToString（）：

调用Arrays.deepToString(),可以理解为深度打印，可以打印二维数组：
public class Demo1 {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3,4}, {4, 5, 6}, {7, 8, 9}};
       // print(a);
        System.out.println(Arrays.deepToString(a));
    }
}

5、数组的练习：
以前写过了，可以通过下面的链接，进去看看数组的练习题：
冒泡排序
二分查找
Arrays的3中常见用法

一、数组
1、概念
数组Array是用于存储多个相同类型数据的集合

想要获取数组中的元素值，可以通过元素下标来获取，下标是从零开始的
  

  数组是最为常见的一种数据结构，是相同类型的用一个标识符封装到一起的基本类型数据序列或对象序列，可以用一个统一的数组名和小标来唯一确定数组中的元素。实质上，数组是一个简单的线性序列，因此访问速度很快。
2、数组的创建
数组的常见分为静态初始化和动态初始化
2.1 静态初始化
静态初始化数组不会指定数组的长度，创建数组的时候就把数据加入到数组中去.
(1) int[]a={1,2,3,4,5,6,7}
(2) int[]a=new int[]{1,2,3,4,5,6}

2.2 动态初始化
数组的动态初始化在创建数组之初只需要指定数组的长度，建立好的数组有着对应类型的默认值，这个默认值和数组的类型作为成员变量的默认值一样，例如int类型数组的数据默认值为0.

int[]a=new int[5]

这里把数组的地址值交给变量a保存
3 数组的长度和遍历
3.1 数组的长度
1、length属性获取数组的长度（数组.length 属性不是方法）
2、数组一旦创建长度不可变
3、允许0长度的数组

3.2 数组的遍历
从头到尾，一次访问数组的位置

3.2.1 for循环遍历
public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int i=0; i<ns.length; i++) {
            int n = ns[i];
            System.out.println(n);
        }
    }
}

3.3.2 for each循环遍历
for each循环虽然机构更加简单，但是无法获得数组的索引，根据实际情况使用。

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 1, 2, 3, 5, 8 };
		for (int n : ns) {
		    System.out.print(n + ", ");
		}
    }
}

4、数组工具类Arrays
工具类里面的里面方法是是静态的方法，不是静态的类
4.1 Arrays.tostring(数组)
把数组里的数据，用逗号连接成一个字符串，格式：[1,2,3,4,5,6].(和直接输出集合的效果一样)

4.2 Arrays.sort(数组)
对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高
对应用类型，使用优化后的合并排序算法。

4.3 Arrays.copyOf(数组，新的长度)
把数组赋值成一个指定长度的新数组
新数组的长度大于原数组，相当于复制，并增加位置。--数组的扩容
新数组的长度小于原数组，相当于截取前一部分数据。--数组的缩容

4.4 方法的具体体现
int[] a = Arrays.copyOf(arr, 10);//数组的复制，大于原来长度相当于扩容
System.out.println(Arrays.toString(a));//[12, 30, 20, 90, 34, 0, 0, 0, 0, 0]
System.out.println(a.length);//10       
int[] a2 = Arrays.copyOf(arr, 3);//数组的复制，晓宇原来长度相当于截取前几个数据
System.out.println(Arrays.toString(a2));//[12, 30, 20]
System.out.println(a2.length);//10

5、数组的拓展
5.1 二维数组
存放数组的数组，也就是说数组里面存的哈市数组的数据形式。


5.2  数组的冒泡法排序
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3、针对所有的元素重复以上的步骤，除了最后一个。

4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
5.3 排序算法（十二种）
5.3.1 排序算法分别有：
插入排序、二分插入排序、希尔排序、选择排序、冒泡排序、鸡尾酒排序、快速排序、堆排序、归并排序、桶排序、计数排序和基数排序
5.3.2 以为算法总结写得非常好的文章
排序散发总结连接

数组的定义

数组是相同类型数据的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们，牢记，下标是从0开始的

数组声明创建

首先必须声明数组变量，才能在程序中使用数组
Java语言使用new操作符来创建数组
数组的元素是通过索引来访问的，数组索引从0开始
获取数组长度：arrays.length

public class Demo01 {
    //变量的类型   变量名 = 变量值
    public static void main(String[] args) {
        int[] nums;//定义，声明一个数组

        nums = new int[10];//创建一个数组，这里面可以放10个变量数字

        //给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;

        System.out.println(nums[0]);
        //计算所有元素的和
        int sum = 0;
        //获取数组长度：arrays.length
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println(sum);
    }
}

数组的三种初始化

静态初始化
动态初始化
数组的默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式的初始化

思维导图：


public class Demo02 {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4,5,6,7,8,9,10,11,12};
        System.out.println(a[2]);

        //动态初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
    }
}

数组的四个特点

数组一旦创建，它的大小就是不可以改变的
元素必须是相同的类型，不允许出现混合类型
数组的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属于引用类型，数组可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身就是在堆中

数组边界

下标的合法区间：[0,length-1]，如果越界就会报错
ArrayIndexOutOfBoundsException：数组下标越界异常

多维数组

多维数组可以看作是数组的数组，二维数组是一个特殊的数组，其每个元素都是一个数组
定义： int a[][] = new int [2][5]
所以可以把这个数组看成是一个两列五行的数组

public class Demo04 {
    public static void main(String[] args) {

        /*
        * 1,2  array[0]
        * 2,3  array[1]
        * 3,4  array[2]
        * 4,5  array[3]
        * */
         int[][] array= {{1,2},{2,3},{3,4},{4,5}};


        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

冒泡排序
public class Demo05 {
    public static void main(String[] args) {
        /*
        * 冒泡排序
        *1.比较数组中两个相邻的元素，如果第一个比第二个数大，我们就交换它的位置
        *2.每一次比较，都会产生一个最大或者最小的数字
        * 下一次比较则少一次排序
        * 一次排序直到结束
        * */

        int[] a = {1,25498,6561,8561,12,356,848,13,2};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));

    }

    public static int[] sort(int[] array){
        //定义一个临时变量，来储存交换的值
        int temp = 0;
        //外层循环，判断我们要执行多少次
        for (int i = 0; i < array.length-1; i++) {
            //内层循环，比较两个数，如果第一个数比第二个数大，交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]){
                   temp = array[j];
                   array[j] = array[j+1];
                   array[j+1] = temp;
                }
            }
        }
        return array;
    }
}