一、Java的内存分配
A:栈内存： 存储局部变量，只要是在方法中定义的变量都是局部变量。一旦变量的生命周期结束该变量就被释放。
B:堆内存： 存储所有new出来的，及实体（对象），每一个实体都有一个首地址值，每一个变量都有默认初始化值，不同类型的不一样。
当实体不在使用时，就会被垃圾回收机制处理。
C:方法区(面向对象部分详细讲解)
D:本地方法区(系统相关)
E:寄存器(CPU使用)
二、数组
(1)定义：存储同一种数据类型的多个元素的容器。
(2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。
编号的专业叫法：索引
(3)定义格式
A:数据类型[] 数组名;(推荐使用）
B:数据类型 数组名[];（知道就好，一般不用）
(4)数组的初始化
A:动态初始化
只给长度，系统给出默认值
举例：int[] arr = new int[3];
B:静态初始化
给出值，系统决定长度
举例：int[] arr = new int[]{1,2,3};
简化版：int[] arr = {1,2,3};
三、数组的常用方法
public class Dome1 {
public static void main(String[] args) {
//使用输入值初始化数组
int[] arr = new int[10];
//调用想要的方法
}
//使用输入值对数组初始化
public static void chu(int[]arr){
Scanner sc = new Scanner(System.in);
System.out.println("请输入数组值：");
for(int x =0;x<arr.length;x++){
arr[x] = sc.nextInt();
}
}
//使用随机数初始化数组
public static void rando(int[] arr){
for(int x=0;x<arr.length;x++){
arr[x] = (int) (Math.random()*100);
}
}
//数组的遍历 方式1
public static void printArray(int[] arr){
for(int x=0;x<arr.length;x++){
System.out.println(arr[x]);
}
}
//遍历方式2
public static void printArray2(int[]arr){
System.out.print("[");
for(int x=0;x<arr.length;x++){
if(x != arr.length-1){
System.out.print(arr[x]+",");
}else{
System.out.print(arr[x]+"]");
}
}
System.out.println();
}
//对数组中的所有元素求和
public static int sum( int arr[]){
int sum = 0;
for(int x=0;x<arr.length;x++){
sum +=arr[x];
}
return sum;
}
//找出最大元素级下标
public static int max(int[] arr){
int max = arr[0];
int indexOfMax = 0;
for(int x=0;x<arr.length;x++){
if(arr[x]>max){
max= arr[x];
indexOfMax = x;
}else{
max = max;
indexOfMax = 0;
}
}
return max;
}
//找出元素最小值及下标
public static int min(int[]arr){
int min = arr[0];
int indexOfMin = 0;
for(int x=0;x<arr.length;x++){
if(arr[x]<min){
min = arr[x];
indexOfMin=x;
}else{
min = min;
}
}
return min;
}
//随意打乱元素
public static void rodm(int[] arr){
for(int x=0;x<arr.length;x++){
int index = (int) Math.random()*arr.length;
//交换下标
int temp = arr[x];
arr[x] = arr[index];
arr[index] = temp;
}
}
//移动元素
public static void shift(int[] arr){
int temp = arr[0];
for(int x=1;x<arr.length;x++){
arr[x-1] = arr[x];
}
arr[arr.length-1] = temp;
}
//增强for 遍历数组
public static void bin(int[]arr){
for (int i : arr) {
System.out.println(arr[i]);
}
}
}
四、数组的排序方法
public class Dome3 {
public static void main(String[] args) {
}
//选择排序
public static void selectionSort(int[] arr){
for(int x=0 ;x<arr.length-1; x++){
//提供比较的空间角标
for(int y=x+1; y<arr.length; y++){
//提供剩余空间的角标
if(arr[x]>arr[y]){
//判断当前外循环角标位置上的值和内循环角标位置上的值
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
//冒泡排序
public static void bubbleSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=0; y<arr.length-1-x; y++)
{
if(arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
}
说明：
1、选择排序
选择排序是排序中的一种。算法原则（从小到大排序）：先用数组中第一个空间值和数组中剩余的其他空间值一一做比较，在比较的过程有任何值比第一个空间值小，就用第一个空间值和当前这个空间值换位置，直到所有值和第一个空间值全部比较完。第一个空间中就放着最小值。接着在使用数组第二个空间值和数组中剩下空间中值做比较，比较方式和前一次相同。以此类推，比较完成。
规律：第一个空间和剩余空间比一圈，第二个空间在和剩余空间比一圈，以此类推，到倒数第二个空间值和最后一个空间值比完，整个数组有有序了。正好符合了外循环循环一次，内循环执行一圈。即外循环控制每次到底使用那个空间值和剩余空间比较，内循环提供剩余空间。
图解：
2、冒泡排序
冒泡排序算法原理：这种算法和生活中常见的水中气泡的浮沉类似。
数组冒泡算法（从小到大）：
第一轮：数字第一个空间值和第二个空间值比较，把较大的值存在第二个空间中，接着第二个空间值和第三个空间值作比较，较大的值存在第三个空间中，以此类推直到倒数第二个空间和倒数第一个空间比较，把较大值存放在最后一个空间中。
第二轮：由于最后一个空间已经是最大值了，那么第二轮算法和第一轮一样，只是最后一次比较是倒数第三个空间和倒数第二个空间比较。把较大的值存在倒数第二个空间中。
以此类推。
图解：
五、数组的查找方法
public class Dome2 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6 };
System.out.println(binarySearch(arr, 6));
}
// 线性查找，根据需要找的数，找到在数组中的下标
public static int linearSearch(int[] arr, int k) {
for (int x = 0; x < arr.length; x++) {
if (k == arr[x]) {
return x;
}
}
return -1;
}
//二分法查找，数组必须有序
public static int binarySearch(int[] arr, int k){
int low = 0;
int high = arr.length-1;
while(high>=low){
int mid = (low+high)/2;
if(k<arr[mid]){
high = mid-1;
}else if(k == arr[mid]){
return mid;
}else{
low = mid+1;
}
}
return -1;
}
}
说明：
1、一半查找
从组中第一个空间开始查找，每取出一个空间值和待查找的数值做比较，若相等，就返回当前角标，若数组遍历结束，没有找到相等的值，则返回-1.
2、二分法查找
折半查找，必须保证数组已经是有序的。
思路：
1，通过角标先获取中间角标上元素。
2，让该元素和要找的数据比较。
3，如果要找的数大了，缩小范围，要找的范围应该是 中间的角标+1---尾角标。
如果要找的数小了，要找的范围 头角标---中间角标-1；
4，不断如此重复，就可以找到元素对应的角标。
六、arrays类
| 序号 | 方法和说明 |
|---|---|
| 1 | public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。 |
| 2 |
public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
| 3 |
public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
| 4 |
public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |