ä¸ã方法

ï¼ä¸ï¼方法交换变量示意图

 

（二）方法重载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");

}