数组
1、Java 中数组是对象吗
- 什么是对象：
语言层面：对象是根据某个类创建出来的一个实例，表示某类事物中一个具体的个体.对象具有各种属性，并且具有一些特定的行为计算机层面：对象就是内存中的一个内存块，在这个内存块封装了一些数据，也就是类中定义的各个属性 - 数组：
语言层面上，数组不是某类事物中的一个具体的个体，而是多个个体的集合，那么数组应该不是对象而在计算机的角度，数组也是一个内存块，也封装了一些数据，这样的话也可以称之为对象
int[] a = new int[4];
//a.length; //对属性的引用不能当成语句
int len = a.length; //数组中保存一个字段， 表示数组的长度
//以下方法说明数组可以调用方法，java中的数组是对象.
//这些方法是Object中的方法，所以可以肯定，数组的最顶层父类也是Object
a.clone();
a.toString();这基本上可以认定，java中的数组也是对象，它具有java中其他对象的一些基本特点：封装了一些数据，可以访问属性，也可以调用方法.所以：Java数组是对象
而在C++中，数组虽然封装了数据，但数组名只是一个指针，指向数组中的首个元素，既没有属性，也没有方法可以调用；所以 C++中的数组不是对象，只是一个数据的集合，而不能当做对象来使用
2、Java中数组的类型
2.1、虚拟机自动创建了数组类型，可以把数组类型和8种基本数据类型一样， 当做java的内建类型：
- 每一维度用一个"[“表示;开头两个”["，就代表是二维数组.
- "["后面是数组中元素的类型(包括基本数据类型和引用数据类型).
2.2、String[] s = new String[4];
- 在java语言层面上，s是数组，也是一个对象，那么他的类型应该是 String[]
- 在JVM中，他的类型为 [java.lang.String
3、Java中数组的继承关系
3.1、数组的顶层父类也必须是 Object
这就说明数组对象可以向上直接转型到 Object，也可以向下强制类型转换，也可以使用 instanceof 关键字做类型判定
//1 在test1()中已经测试得到以下结论： 数组也是对象， 数组的顶层父类是Object， 所以可以向上转型
int[] a = new int[8];
Object obj = a ; //数组的父类也是Object，可以将a向上转型到Object
//2 那么能向下转型吗?
int[] b = (int[])obj; //可以进行向下转型
//3 能使用instanceof关键字判定吗?
if(obj instanceof int[]){ //可以用instanceof关键字进行类型判定
System.out.println("obj的真实类型是int[]");
}3.2、Java中数组的另一种"继承"关系
String[] s = new String[5];
Object[] obja = s; //成立，说明可以用Object[]的引用来接收String[]的对象
// s的直接父类是?
//5那么String[] 的直接父类是Object[] 还是 Object?
System.out.println(s.getClass().getSuperclass().getName());
//打印结果为java.lang.Object，说明String[] 的直接父类是 Object而不是Object[] - 数组类直接继承了 Object，关于 Object[]类型的引用能够指向
String[]类型的对象，这并不是严格意义上的继承，String[] 不继承自Object[]，但是可以允许 String[]向上转型到
Object[]；可以理解为：其实这种关系可以这样表述：如果有两个类A和B，如果B继承(extends)了A，那么A[]类型的引用就可以指向B[]类型的对象 - 数组的这种用法不能作用于基本类型数据
int[] aa = new int[4];
Object[] objaa = aa; //错误的，不能通过编译
因为 int 不是引用类型，Object 不是 int 的父类，在这里自动装箱不起作用
Object 数组中可以存放任何值，包括基本数据类型
public class ArrayTest {
public static void main(String[] args) {
test1();
test2();
test3();
}
/**
* 数组具有这种特性：
* 如果有两个类A和B，如果B继承(extends)了A，那么A[]类型的引用就可以指向B[]类型的对象
* 测试数组的特殊特性对参数传递的便利性
*/
private static void test3() {
String[] a = new String[3];
doArray(a);
}
private static void doArray(Object[] objs){
}
private static void doArray1(Object obj){
//不能用Object接收数组，因为这样无法对数组的元素进行访问
// obj[1] //错误
//如果在方法内部对obj转型到数组，存在类型转换异常的风险
// Object[] objs = (Object[]) obj;
}
private static void doArray2(String[] strs){
//如果适用特定类型的数组，就限制了类型，失去灵活性和通用性
}
private static void doArray3(String name， int age， String id， float account){
//如果不适用数组而是依次传递参数，会使参数列表变得冗长，难以阅读
}
/**
* 测试数组的集成关系， 并且他的继承关系是否和数组中元素的类型有关
*/
private static void test2() {
//1 在test1()中已经测试得到以下结论： 数组也是对象， 数组的顶层父类是Object， 所以可以向上转型
int[] a = new int[8];
Object obj = a ; //数组的父类也是Object，可以将a向上转型到Object
//2 那么能向下转型吗?
int[] b = (int[])obj; //可以进行向下转型
//3 能使用instanceof关键字判定吗?
if(obj instanceof int[]){ //可以用instanceof关键字进行类型判定
System.out.println("obj的真实类型是int[]");
}
//4 下面代码成立吗?
String[] s = new String[5];
Object[] obja = s; //成立，说明可以用Object[]的引用来接收String[]的对象
//5 那么String[] 的直接父类是Object[] 还是 Object?
System.out.println(s.getClass().getSuperclass().getName());
//打印结果为java.lang.Object，说明String[] 的直接父类是 Object而不是Object[]
//6 下面成立吗? Father是Son的直接父类
Son[] sons = new Son[3];
Father[] fa = sons; //成立
//7 那么Son[] 的直接父类是Father[] 还是 Object[] 或者是Object?
System.out.println(sons.getClass().getSuperclass().getName());
//打印结果为java.lang.Object，说明Son[]的直接父类是Object
/**
* 做一下总结， 如果A是B的父类， 那么A[] 类型的引用可以指向 B[]类型的变量
* 但是B[]的直接父类是Object， 所有数组的父类都是Object
*/
//8 上面的结论可以扩展到二维数组
Son[][] sonss = new Son[2][4];
Father[][] fathers = sonss;
//将Father[][]数组看成是一维数组， 这是个数组中的元素为Father[]
//将Son[][]数组看成是一维数组， 这是个数组中的元素为Son[]
//因为Father[]类型的引用可以指向Son[]类型的对象
//所以，根据上面的结论，Father[][]的引用可以指向Son[][]类型的对象
/**
* 扩展结论：
* 因为Object是所有引用类型的父类
* 所以Object[]的引用可以指向任何引用数据类型的数组的对象. 如：
* Object[] objs = new String[1];
* Object[] objs = new Son[1];
*
*/
//9 下面的代码成立吗?
int[] aa = new int[4];
//Object[] objaa = aa; //错误的，不能通过编译
//这是错误的， 因为Object不是int的父类，在这里自动装箱不起作用
//10 这样可以吗？
Object[] objss = {"aaa"， 1， 2.5};//成立
}
/**
* 测试在java语言中，数组是不是对象
* 如果是对象， 那么他的类型是什么?
*/
private static void test1() {
int[] a = new int[4];
//a.length; //对属性的引用不能当成语句
int len = a.length; //数组中保存一个字段， 表示数组的长度
//以下方法说明数组可以调用方法，java中的数组是对象.这些方法是Object中的方法，所以可以肯定，数组的最顶层父类也是Object
a.clone();
a.toString();
/**
* java是强类型的语言，一个对象总会有一个特定的类型，例如 Person p = new Person();
* 对象p(确切的说是引用)的类型是Person类， 这个Person类是我们自己编写的
* 那么数组的类型是什么呢? 下面使用反射的方式进行验证
*/
int[] a1 = {1， 2， 3， 4};
System.out.println(a1.getClass().getName());
//打印出的数组类的名字为[I
String[] s = new String[2];
System.out.println(s.getClass().getName());
//打印出的数组类的名字为 [Ljava.lang.String;
String[][] ss = new String[2][3];
System.out.println(ss.getClass().getName());
//打印出的数组类的名字为 [[Ljava.lang.String;
/**
* 所以，数组也是有类型的，只不过这个类型不是有程序员自己定义的类， 也不是jdk里面
* 的类， 而是虚拟机在运行时专门创建的类
* 类型的命名规则是：
* 每一维度用一个[表示;
* [后面是数组中元素的类型(包括基本数据类型和引用数据类型)
*
* 在java语言层面上，s是数组，也是一个对象，那么他的类型应该是String[]，
* 但是在JVM中，他的类型为[java.lang.String
*
* 顺便说一句普通的类在JVM里的类型为 包名+类名， 也就是全限定名
*/
}
public static class Father {
}
public static class Son extends Father {
}
}4、Java 数组初始化
Java 数组是静态的，即当数组被初始化之后，该数组的长度是不可变的;
5、数组扩容
可以参照利用 List 集合中的add方法模拟实现
// datas 原始数组 newLen 扩容大小
public static <T> T[] expandCapacity(T[] datas，int newLen){
newLen = newLen < 0 ? datas.length ：datas.length + newLen;
//生成一个新的数组
return Arrays.copyOf(datas， newLen);
}
// datas 原始数组
public static <T> T[] expandCapacity(T[] datas){
int newLen = (datas.length * 3) / 2; //扩容原始数组的1.5倍
//生成一个新的数组
return Arrays.copyOf(datas， newLen);
}
// datas 原始数组 mulitiple 扩容的倍数
public static <T> T[] expandCapacityMul(T[] datas，int mulitiple){
mulitiple = mulitiple < 0 ? 1 ： mulitiple;
int newLen = datas.length * mulitiple;
return Arrays.copyOf(datas，newLen );
}6、数组复制问题
所以通过 Arrays.copyOf() 方法产生的数组是一个浅拷贝。同时数组的 clone() 方法也是，集合的 clone() 方法也是，所以我们在使用拷贝方法的同时一定要注意浅拷贝这问题
7、数组转换为 List
asList 返回的是一个长度不可变的列表。数组是多长，转换成的列表就是多长，我们是无法通过 add、remove 来增加或者减少其长度的
public static void main(String[] args) {
int[] datas = new int[]{1，2，3，4，5};
List list = Arrays.asList(datas);
System.out.println(list.size()); // 1
}为什么上述结果输出为 1？
首先看 asList的源码：
public static <T> List<T> asList(T... a) {
return new ArrayList<T>(a);
}- 注意这个参数：T…a，这个参数是一个泛型的变长参数，我们知道基本数据类型是不可能泛型化的，也是就说 8个基本数据类型是不可作为泛型参数的， 但是为什么编译器没有报错呢？这是因为在 Java 中，数组会当做一个对象来处理，它是可以泛型的，所以我们的程序是把一个 int 型的数组作为了 T 的类型，所以在转换之后 List中就只会存在一个类型为 int 数组的元素了；
- 这里是直接返回一个 ArrayList 对象返回，但是注意这个 ArrayList 并不是 java.util.ArrayList，而是
Arrays 工具类的一个内之类，这个内部类并没有提供 add() 方法，那么查看父类 AbstractList仅仅只是提供了方法，方法的具体实现却没有，所以具体的实现需要子类自己来提供，但是非常遗憾这个内部类ArrayList 并没有提供 add 的实现方法
size：元素数量、toArray：转换为数组，实现了数组的浅拷贝、get：获得指定元素、contains：是否包含某元素
8、Java中length和length()的区别
- 1、获取数组的长度是使用属性 length，获取字符串长度是使用方法 length()
- 2、为什么数组有length属性?
数组是一个容器对象，其中包含固定数量的同一类型的值.一旦数组被创建，那么数组的长度就是固定的了。数组的长度可以作为final实例变量的长度。因此，长度可以被视为一个数组的属性 - 有两种创建数组的方法：1、通过数组表达式创建数组。2、通过初始化值创建数组。无论使用哪种方式，一旦数组被创建，其大小就固定了
- 3、Java 中为什么没有定义一个类似 String 一样 Array 类：数组包含所有从 Object继承下来方法，为什么没有一个array类呢?一个简单的解释是它被隐藏起来了
- 4、为什么 String 有length()方法？
背后的数据结构是一个 char 数组，所以没有必要来定义一个不必要的属性(因为该属性在 char 数值中已经提供了)
别废话,拿你代码给我看。
