java数组

定义数组（下面这三个都是动态数组）：
格式：数据类型[]数组名称=new 数据类型[长度]；
float[] a=new float[10];//a可以装10个float数据
int[] a=new int[10];//a可以装10个int数据
String[] a=new String[10]//a可以装10个String数据
数组的特点：
1.数组时用来存储一组相同数据类型的数据结构
2.数组中的元素可以是任何数据类型（基本和引用）
3.有索引值可以通过索引值来访问每个元素
4.数组被创建好后，他的大小（长度）是不能变的，能变是数组中元素
5.数组属于引用数据类型
6.数组有一个常用属性：length 例如：int c=a.length指的是a的长度赋值给了c
7.数组中的元素没有赋值的时候int类型的默认值为0，String类型的默认值是null，float和double类型的默认值都是0.0，数组可以不赋值但不能添加的元素超过数组的长度（报错，越界了），
基本类型的传递是值传递，引用类型（内存地址）的传递的本质是：同一块堆内存空间可以被不同栈内存所指向，java把内存分为两种，栈内存和堆内存，函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存的分配，当代码定义了一个变量，java就在栈中为这个变量分配空间，当超过作用域后被自动释放内存也就是说这个空间可以被立刻另作它用。堆内存用于存放new创建的对象和数组，在堆中分配的内存由java虚拟机（jvm）自动垃圾回收器来管理。在堆内存中产生一个数组和对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊变量就变成了数组或者对象的引用变量，以后就可以使用栈内存中的引用变量来访问堆中的数组或者对象了，引用变量是普通变量，定义时在栈中被分配，引用变量在程序运行到作用域之外被自动释放，而数组和对象本身在堆中分配，即使程序运行到使用new产生的数组和对象的语句所在地代码块之外，数组和对象本身的内存也不会被释放，数组和对象在没有引用变量指向它的时候，才会变成垃圾，不能再被使用，但是仍要占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这也是java比较占内存的主要原因，实际上，栈中的变量指向堆内存中的变量，这就是java的指针！
public class ArrayDemo {
public static void main(String args[]) {
int data[] = null;
data = new int[3]; //开辟一个长度为3的数组
int temp[] = null; //声明对象
data[0] = 10;
data[1] = 20;
data[2] = 30;
temp = data; //int temp[] = data;
temp[0] = 99;
for(int i = 0; i < temp.length; i++) {
System.out.println(data[i]);
}
}
}
运行结果为：99 20 30
用for遍历数组时：基本for，可以遍历元素值（取元素值），也可以改变元素值，即在循环后通过索引把值赋值，然后输出。加强for只能遍历不能元素不能改变元素
原因：在堆中数组值得改变只能通过索引改变，所以基本for能改变数组的值，而加强for没有索引值，改变的是栈中的变量值，在堆中数组的值仍不变
数组静态初始化
简化格式：数据类型[] 数组名称={值，值，…};
完整格式：数据类型[] 数组名称 =new 数据类型[]{值，值…};
例如：int[] data = {1,2,3,4,5,6,7,8};
int[] data = new int[]{1,2,3,4,5,6,7,8}
二维数组
数组的动态初始化：数据类型[][] 对象数组 = new 数据类型[行个数][列个数]；
数组的静态初始化：数据类型[][] 对象数组 = new 数据类型[行个数][列个数]{{值,…},{值，…}}
例如： int[][] c = new int[][]{{1,2},{2,3,4}};
用加强for来遍历二维数组for（int[] b：c）{
for（int a：b）{
Systems.out.print(a+"\t");
}
}
Systems.out.print();
排序：常用的排序有冒泡、插入、快速、选择等
冒泡排序
int[] a={1,8,6,15,86,14,3};
for(int i=0;i<a.length-1;i++){
for(int j=0；j<a.length-1-i；j++){
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
for(int x:a){
System.out.print(x+" “);（第一种输出）
}
为什么最后要遍历数组后才能输出？
for(int x=0;x<a.length;x++){
System.out.print(a[x]+” “);}（第二种输出）
还有一种System.out.print(x+” “);（第三种），第三种我们直接打印的到的数组是JVM（Java虚拟机）中的引用地址。第一第二中直接把每个元素拿出来进行了冒泡，
我们要打印元素的内容，java标准库提供了Arrays.toString（数组）可以快速打印出数组，
格式： import java.util.Arrays(首先要导入类)
…
Systme.out.print(Arrays.toString(a))；//将数组元素转字符串打印输出
自己也可以写Arrays（MyArrays）类以及他的toString方法
public class MyArrays{
public static String toString{
String b =”[";
for(int i=0;j<a.length;i++){
if(i==a.length-1){
b=b+a[i];
}else{
b=b+a[i]+", “;
}
}
b=b+”]";
return b;
}
}
public static void main(String[] args) { } :这个是自身调用程序时的方法，方法与方法直接不能嵌套，是平级的。调用一个类中的方法时接收口（能不能被调用）修饰符来决定能不能被调用：public，protected，default，private
选择排序
选择排序：就是拿数组中的每个元素都跟其后面的元素相比较，前面大了，换到后面
a[0]跟a[1]比完大小后 a[0]再和a[2]比 等依次类推
import java.util.Arrays;
int[] a={8,9,6,4,3,5}
for(int i =0;i<a.length-1;i++){
for(int j=i+1;j<a.length;j++){
if(a[i]>a[j]){
int temp =a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
System.out.print(Arrays.out.print(a));
Arrays类中的快速升序
import java.util.Arrays;
int[] a={8,9,6,4,3,5}；
Arrays.sort(a);
for(int i=0;i<a.length;i++){
System.out.print(a[i])
}