ä¸ã 方法
ï¼ä¸ï¼ 方法交换变量示意图
（二）方法重载overload
概念：在同一个类的内部，方法名字相同，参数列表不同，与返回类型无关的方法，称之为方法的重载。
方法名字相同：代表重载的方法实现的是类似的功能。
参数列表不同：参数的个数不同、参数的类型不同、顺序不同。
与返回类型无关：对于返回类型不是void 的方法，通常的用法是使用该方法参与某些计算的表达式。但是也可以直接调用，而不参与任何的运算。与返回类型是void 的直接调用的方式是有语义的冲突的。（保证方法的签名 signature 唯一性）。
äºã 数组array
（一）概念：数组是一个对象，是一个包含了一组变量的集合对象。这一组变量的类型必须一致。
初识数组：
1：数组是我们在java 中需要了解的第一种引用数据类型。
2：如何定义数组：申请内存空间的过程。
语法：数组中变量的类型[] 数组变量名 = new 数组中变量的类型[变量的个数];
int[] scores = new int[10];
数组中的变量的类型 可以是 java 支持的任意类型。
boolean[] bools = new boolean[10];
3: 数组中的这一组变量的类型必须一致。
4：new 是一个java 关键字用来向 jvm 申请内存的。所有的变量的内存都是在堆中连续分配的。
5：通过new申请完内存之后，每一个数组内部的变量就有内存空间即每个变量就有值了！
每个变量在分配完空间之后，会由jvm 进行默认的初始化。
默认初始化的规则：变量类型是整数类型 = 0 -- char = '\u0000' -- float和double = 0.0 -- boolean = false -- 引用数据类型 = null.
6：数组中的变量被称之为数组元素 element。
7：如何访问数组元素：通过 数组名[元素序号]。
8：数组中的每个元素都被默认赋予了一个顺序号。序号从0开始，是连续的，序号的专业名称：元素的下标、索引、角标(index)。数组的最小下标是 0 ，最大下标是[元素个数-1]。
9：数组对象包含了一个属性，一个int 类型的长度属性即元素的个数。通过 数组名.length 获得数组元素的个数。
10：数组变量名 是 一个引用（一种更加安全的地址）。
11：数组元素的个数一旦确定，那么就不能再更改了。数组是定长的。
（二）数组的初始化
数组初始化的方式：
1：动态初始化：
int[] scores = new int[10];
动态初始化就是在运行期通过 new 向jvm 动态的申请内存。jvm 会根据申请的内存的大小，在堆区中找一段连续的适合的大小的内存空间给数组元素使用。jvm 并对所有的元素进行默认初始化。
可以将声明 和 初始化分开进行。
int age;
age =10;
int[] scores;
scores = new int[10];
2：静态初始化：
int[] scores = new int[]{1,2,3,54,6}; 元素的初始值 和 元素的个数 由大括号内的数值的个数来决定。
可以将声明 和 初始化分开进行。
int[] scores;
scores = new int[]{1,6,5,3};
适合元素数量比较少，元素的值通常是不再变化的。
3：静态初始化的其他的语法形式：
int[] scores = {56,7,8};
元素的个数和元素的初始值都由大括号内的数值决定。
限制：声明 和 赋值 必须在同时进行。必须一句代码完成。
数组声明的多种语法形式：
[]的位置可以在数据类型和数组名之间的任何位置，也可以在数组名之后
public static void testArray2(){
int[] values1 = new int[10];
int values2[] = new int[5];
int [] values3 = new int[6];
int []values4 = new int[6];
}
（三）数组内存分配图
例1：
public class TestArray1{
public static void main(String[] args){
testArray1();
}
// 随机得到 10个学生的分数[60~100]，求学生分数的平均值 ，和 总分。
public static void testArray(){
final int COUNT = 10;
final int MIN = 60;
final int MAX = 101;
int sum = 0;
int avg = 0;
//使用for 循环得到是个随机的分数，累加到sum 上
for(int i=0;i<COUNT;i++){
int score = randomNumberByRange(MIN,MAX);
sum += score;
}
avg = sum/COUNT;
print("sum = "+sum);
print("avg = "+avg);
//还要查看每个学生具体的分数 定义多个变量保存多个学生的数据的方式 肯定不是最合适的选择。
//需求：如果一个变量 可以保存 任意个数据，那这个问题就解决了
}
public static void testArray1(){
final int COUNT = 10;
final int MIN = 60;
final int MAX = 101;
int sum = 0;
int avg = 0;
//定义数组 保存一组分数的变量
//申请COUNT 个 int 类型的变量空间。
int[] scores = new int[COUNT];
//使用for 循环得到是个随机的分数，累加到sum 上
//如何去访问每一个分数变量 ： 通过 数组变量名[变量的序号(0~变量个数-1)]
for(int i=0;i<COUNT;i++){
//对每个数组中的分数变量赋值。
scores[i] = randomNumberByRange(MIN,MAX);
sum += scores[i];
}
avg = sum/COUNT;
print("sum = "+sum);
print("avg = "+avg);
//打印每个数组中的分数变量的值。
for(int i=0;i<COUNT;i++){
print("第 "+(i+1)+" 个学生的分数为："+scores[i]);
}
}
public static void print(String str){
System.out.println(str);
}
public static int randomNumberByRange(int min, int max){
return (int)(Math.random()*(max-min)+min);
}
}
例2：
//定义一个boolean类型的数组，动态初始化，长度随机[5-10];并打印输出数组的长度。然后对数组元素随机赋值 Random提供的nextBoolean 方法。
//遍历输出数组的元素的内容。 上述内容，在一个自定义的方法内实现。
public static void testBooleanArray(){
final int MIN = 5;
final int MAX = 11;
int length = randomNumberByRange(MIN, MAX);
System.out.println("length = "+length);
boolean[] bools = new boolean[length];
Random random = new Random();
//使用for 循环对数组元素逐一赋值
for(int i=0;i<bools.length;i++){
bools[i] = random.nextBoolean();
}
for(int i=0;i<bools.length;i++){
System.out.print(bools[i] + "\t");
}
}
例3：
//写一个方法：功能要求：定义一个byte类型的数组，长度为5，静态初始化，元素的数值要求随机，范围[0-100],最后遍历输出数组的内容。
public static void testByteArray(){
final int MIN = 0;
final int MAX = 101;
byte[] values = {
(byte)randomNumberByRange(MIN, MAX),
(byte)randomNumberByRange(MIN, MAX),
(byte)randomNumberByRange(MIN, MAX),
(byte)randomNumberByRange(MIN, MAX),
(byte)randomNumberByRange(MIN, MAX)
};
for(int i=0;i<values.length;i++){
print("\t"+values[i]);
}
}
例4：
// 1:定义一个方法，根据给定的长度，动态初始化一个int类型元素数组，然后对元素随机赋值 根据给定的区间。并返回该数组 就是返回数组变量。
// 2:通过上面的方法，得到一个数组之后，再自定一个方法，对给定的数组，求出该数组中存在内容为指定值 的元素的数量。
// 有多少个元素和指定的值相同，，最后输出结果。
// 3:方法要求：将指定数组元素的内容为指定值的索引(数组下标)全部返回。返回一个数组，数组中包含的是指定数组的元素的索引值。
public class TestArray2{
public static void main(String[] args){
int[] arr = getRandomArray(6, 0, 17);
printArray(arr);
int key = 6;
int count = getEleCountByKey(arr , key);
print("数组中元素值为："+ key + " 的元素的数量为："+count);
int[] indexes = getEleIndexesByKey(arr, key);
printArray(indexes);
}
// 1:定义一个方法，根据给定的长度，动态初始化一个int类型元素数组，然后对元素随机赋值 根据给定的区间。并返回该数组 就是返回数组变量。
public static int[] getRandomArray(int length, int min, int max){
//动态初始化一个int类型的数组
int[] arr = new int[length];
//对数组元素随机赋值
for(int i=0;i<length;i++){
arr[i] = randomNumberByRange(min, max);
}
//返回得到的数组
return arr;
}
// 2:通过上面的方法，得到一个数组之后，再自定一个方法，对给定的数组，求出该数组中存在内容为指定值 的元素的数量。
public static int getEleCountByKey(int[] arr, int key){
//定义计数器
int counter = 0;
//遍历数组元素，逐个使用key 和每一个元素比较，相等的话 计数器加一
for(int i= 0;i < arr.length ; i++){
if(arr[i] == key){
counter ++;
}
}
//最后返回计数器
return counter;
}
//求 arr 中 所有的元素 和 key 值相等的 元素下标的集合
public static int[] getEleIndexesByKey(int[] arr, int key){
//定义数组用来保存 满足条件的 数组元素的下标
int count = getEleCountByKey(arr, key);
int[] indexes = new int[count];
//遍历数组，将满足条件的元素的下标依次保存到指定的数组中
//定义用来标记当前数组下标的变量
int index = 0;
for(int i=0;i<arr.length;i++){
if(arr[i] == key){
//每放入一个元素，用于记录下标的变量自增一次，下次再放元素的时候，放到下一个还没存放下标的元素的位置
indexes[index++] = i;
// index ++;
}
}
//最后返回数组
return indexes;
}
//自定义方法，实现对int 类型的数组的内容的打印[1, 3, 5, 8]
public static void printArray(int[] array){
//如果数组的长度为0 ，那么就打印一对空的[]
if(array.length == 0){
print("[]");
return;
}
System.out.print("[");
//最后一个元素不打印
for(int i=0;i<array.length-1;i++){
System.out.print(array[i] + ", ");
}
//单独打印最后一个元素
System.out.print(array[array.length-1]+"]\n");
}
public static int randomNumberByRange(int min, int max){
return (int)(Math.random()*(max-min)+min);
}
public static void print(String str){
System.out.println(str);
}
}
例5：
//自定义方法实现对任意的int 类型元素的数组，求出该数组的最大值
public static int max(int[] arr){
int max = arr[0];
//将元素的最大值 赋值 给 max
for(int i=1;i<arr.length;i++){
// 如果元素的值 大于 max 就把元素的值赋值给max
if(arr[i] > max){
max = arr[i];
}
}
return max;
}
（四）数组作为参数交换元素的值的内存图
ï¼1ï¼ 数组删除元素
//删除元素 （指定下标）：直接在源数组上删除。后续的元素需要整体前移。（最后的元素不需要处理）。 最后返回数组的有效数据的个数。
public static int removeElementByIndex(int[] srcArr , int removeIndex){
// 源数组 堆内存都没有空间
if(srcArr == null){
return -1;
}
int len = srcArr.length;
//元素长度为0
if(len == 0){
return 0;
}
//removeIndex 不在区间之内
if(removeIndex < 0 || removeIndex > len -1){
return -2;
}
//逐个移位
for(int i= removeIndex + 1; i < len ;i++){
//将当前i 的位置上的元素的值 赋值给 它前面的一个元素的值 i-1
srcArr[i-1] = srcArr[i];
}
return len-1;
}
ï¼2ï¼ 数组插入元素
//在指定的索引处的插入一个元素。该位置的原来的元素和后续的所有的元素整体后移。挤掉最后一个元素
public static void insertValueByIndex(int[] arr, int insertIndex, int insertValue){
//逐个将插入的位置的元素逐个后移 逆序移动
for(int i= arr.length-2 ;i >= insertIndex;i--){
arr[i+1] = arr[i];
}
//将插入的数据放到指定的位置
arr[insertIndex] = insertValue;
}
ï¼3ï¼ 增强for循环（for -- each）
增强的for 循环：for-each（jdk1.5 版本之后）
作用：用来遍历容器的。可以用来遍历数组。只能用来遍历元素，不能用来修改元素的值。
使用增强的for 循环访问的数组的数据，都是源数组的元素的拷贝。
语法：
int[] arr = new int[10];
for(int value : arr){
}
for(int i=0;i<arr.length;i++){
arr[i]
}
arr 是被遍历的数组。
value 是循环每迭代一次，从arr 中顺序的取出的元素的值。
总结：增强的for 循环其实没有增强，反而功能被削弱了！
for-each 只能用来遍历数组，不能在循环中修改元素的值。
好处：语法相对简单了一点。
public static void printArrayForEach(int[] array){
//如果数组的长度为0 ，那么就打印一对空的[]
if(array.length == 0){
print("[]");
return;
}
System.out.print("[");
for(int value : array){
System.out.print(value + ", ");
}
System.out.print("]\n");
}
