Java学习day07
作者：互联网
数组
1.数组的概念
一组
连续存储的空间，存储多个相同类型的数值，长度是固定的。
2.数组的定义
1.先声明、在分配空间：
数组类型[] 数组名；
数组名 = new 数组类型[长度]；
2.声明并分配空间：
数组类型 [] 数组名 = new 数组类型[长度];
3.声明并赋值（繁）:
数组类型[] 数组名 = new 数组类型[]{value1,value2,value3,.....}
4.声明并赋值（简）：
数组类型[] 数组名 ={value1,value2,value3,.....}；
package com.atguigu.demo.demo1;
/**
* 数组：
* 数组的四种定义方式：
* 方式1 先声明 再分配空间
* 方式2 连声明带分配空间
* 方式3 声明并且赋值(繁)
* 方式4 声明并且赋值(简)
*
*/
public class Test1{
public static void main(String [] args ){
//方式1 先声明 再分配空间
int [] array01; //等价于int array01[] ;
arrray01 = new int [3];
//方式2 连声明带分配空间
int array02 = new int [3];
//方式3 声明并且赋值(繁)
int array03 = new int[]{1,2,3};
//方式4 声明并且赋值(简)
int array04 ={1,2,3};
}
}
3.数组的下标和访问
元素：数组中的每一个数据称为元素
下标（索引|角标）：下标从0开始 自动生成 数组中的每个元素都可以通过下标来访问
数组的访问：访问包括赋值和取值
访问方式：数组名[index下标]
不能访问超出范围的下标，将会出现数组下标越界异常
package com.atguigu.demo.demo1;
/**
* 元素：数组中的每个数据称之为元素
* 下标/索引/角标 ： 下标从0开始 自动生成 数组中的每个元素可以通过下标来访问 访问包括赋值/取值
* 访问方式：数组名[index下标]
*/
public class Test2{
public static void main(String [] args){
int [] arr1 = new int[5];
// 赋值
arr1[0] = 11;
arr1[1] = 22;
arr1[2] = 56;
arr1[3] = 78;
arr1[4] = 88;
// arr1[6] = 100; 不能访问超出下标范围的元素 将报数组下标越界以上 ArrayIndexOutOfBoundsException
// 取值
System.out.println("数组中的第1个元素值为：" + arr1[0]);
System.out.println("数组中的第2个元素值为：" + arr1[1]);
System.out.println("数组中的第3个元素值为：" + arr1[2]);
System.out.println("数组中的第4个元素值为：" + arr1[3]);
System.out.println("数组中的第5个元素值为：" + arr1[4]);
// System.out.println("数组中的第6个元素值为：" + arr1[5]);
// 不能访问超出下标范围的元素 将报数组下标越界以上 ArrayIndexOutOfBoundsException
}
}
4.数组的访问
循环遍历：逐一将数组中的的每个元素进行访问 赋值取值
package com.atguigu.demo.demo1;
import java.util.Scanner;
/**
* 循环的遍历：逐一将数组中的每个元素进行访问 赋值/取值
*/
public class{
public static void main(String [] args){
Scanner input = new Scanner(System.in);
/*System.out.print("请输入数组名称：");
String arrName = input.next();*/
System.out.print("请输入数组长度");
int arrLength = input.nextInt();
int [] nums=new int[arrLength];
// 通过循环给数组中的元素赋值
for(int i = 0;i < 5;i++){
System.out.println("请输入数组中的第" + (i + 1) + "个元素");
nums[i] = input.nextInt();
}
System.out.println("元素赋值完成");
// 通过循环将数组中的元素取出来
for(int i = 0;i < 5;i++){
System.out.print(nums[i] + "\t");
}
System.out.println();
}
}
6.数组的属性及默认值
数组的属性：
length 表示数组的长度 是一个int类型的整数数值 可以通过数组名.length来查看数组长度
数组的默认值：
整数：0
小数：0.0
布尔：false
字符：\u0000
其他：null
package com.atguigu.demo.demo1;
/**
* 数组
* 属性:
* length int型整数值 可以通过数组名.length来查看数组的长度
* 默认值:
* 整型：0
* 浮点型：0.0
* Boolean：false
* char:\u0000 表示空字符
* 其他：null
*/
public class Test4 {
public static void main(String[] args) {
System.out.println("=====================byte===================");
byte [] b1 = new byte[5];
for (int i = 0; i < b1.length; i++) {
System.out.print( + b1[i]+"-\t");
}
System.out.println();
System.out.println("=====================short===================");
short [] s1 = new short[5];
for (int i = 0; i < s1.length; i++) {
System.out.print( s1[i]+"-\t");
}
System.out.println();
System.out.println("=====================int===================");
int [] i1 = new int[5];
for (int i = 0; i < i1.length; i++) {
System.out.print( i1[i]+"-\t");
}
System.out.println();
System.out.println("=====================long===================");
long [] l1 = new long[5];
for (int i = 0; i < l1.length; i++) {
System.out.print( l1[i]+"-\t");
}
System.out.println();
System.out.println("=====================char===================");
char [] c1 = new char[5];
for (int i = 0; i < c1.length; i++) {
System.out.print("-"+ c1[i]+"-");
}
System.out.println();
System.out.print("------------");
char cha1 = '\u0000';
System.out.println(cha1);
System.out.print("------------");
System.out.println();
System.out.println("=====================String===================");
String [] str1 = new String[5];
for (int i = 0; i < str1.length; i++) {
System.out.print(str1[i]+"-\t");
}
System.out.println();
}
}
6.数组扩容
- 数组的扩容
- 创建比原数组更长的数组
- 依次将原数组中的元素复制到新数组
- 通过数组的赋值来实现数组扩容
数组作为引用数据类型，其数组名(引用)中存放的是指向堆中的地址，所以如果直接将一个数组赋值给另外一个数组，本质是赋值的地址
package com.atguigu.demo.demo1;
/**
* 数组扩容：
* 1.声明一个长度大于原数组的新数组
* 2.将就数组里的值复制到新数组对应位置
* 3.将新数组赋予旧数组（新数组代表地址的哈希值给旧数组）
*/
public class Test5 {
public static void main(String[] args) {
int [] oldArr={1,2,3,4,5};
System.out.println(oldArr);
//1.声明一个长度大于原数组的新数组
int [] newArr = new int[oldArr.length*2];
System.out.println(newArr);
// 2.将就数组里的值复制到新数组对应位置
for (int i = 0; i < newArr.length; i++) {
newArr[i]=oldArr[i];
}
System.out.println("====");
// 3.将新数组赋予旧数组（新数组代表地址的哈希值给旧数组）
oldArr=newArr;
System.out.println(oldArr);
System.out.println(newArr);
//输出
for (int i = 0; i < oldArr.length; i++) {
System.out.print(newArr[i]+"\t");
}
}
}
7.课堂练习
统计int类型数组中所有元素的总和。
统计int类型数组中所有元素的平均值。
package com.atguigu.demo.demo2;import java.util.Arrays;
import java.util.Scanner;
/**
* 练习
*/
public class Test1 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int [] arr1=new int[5];
for (int i = 0; i < arr1.length; i++) {
System.out.print("请输入第"+(i+1)+"各元素:");
arr1[i] = input.nextInt();
}
System.out.println("数组元素之和为："+addArray(arr1));
System.out.println("数组元素的平均数为："+averageArray(arr1));
System.out.println("最大值："+maxArray(arr1));
System.out.println("最小值："+minArray(arr1));
}
public static int addArray(int [] arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
}
public static int averageArray(int [] arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum/arr.length;
}
public static int maxArray(int [] arr){
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if(max<arr[i]){
max = arr[i];
}
}
return max;
}
public static int minArray(int [] arr){
int min = arr[0];
for (int i = 0; i < arr.length; i++) {
if(min > arr[i]){
min = arr[i];
}
}
return min;
}
}
8.复制数组的三种方式
复制数组的三种方式：
- 自己编写循环实现复制
- System.arraycopy（原数组，原起始位置，新数组，新起始位置，长度）；
- java.util.Arrays.copyOf(原数组，新长度);此方法会返回一个新的数组···
package com.atguigu.demo.demo2;
import java.util.Arrays;
/**
* 数组复制三种方法：
* 1.自己写for循环复制;
* 2.System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);
* 3.java.util.Arrays.copyOf(原数组，新长度); 此方法会返回一个新的数组;
*/
public class Test2 {
public static void main(String[] args) {
int [] oldArray = {1,2,3,4,5,6,7,8,9};
//第一种：System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);
int [] newArray1 = new int[oldArray.length];
System.arraycopy(oldArray,1,newArray1,2,(oldArray.length-2));
printArray(newArray1);
System.out.println("=============================================");
//第二种：java.util.Arrays.copyOf(原数组，新长度); 此方法会返回一个新的数组;
int [] newArray2 = Arrays.copyOf(oldArray,10);
printArray(newArray2);
}
public static void printArray(int [] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
System.out.println();
}
}
9.数组参数/返回值/可变长参数
数组作为参数/返回值与之前使用方式一致
package com.atguigu.demo.demo2;
import java.util.Scanner;
/**
* 数组类型的参数和返回值
* 需求：
* 1.编写方法统计一个班的学生成绩 作为返回值返回
* 2.编写方法打印一个班的学生成绩
*/
public class Test3 {
public static void main(String[] args) {
double [] scores = getScore();
printScore(scores);
}
public static double[] getScore(){
Scanner input = new Scanner(System.in);
System.out.println("请输入班级人数");
int num = input.nextInt();
double [] scores = new double[num];
for (int i = 0; i < scores.length; i++) {
System.out.println("请输入第" + (i + 1) + "个人的成绩");
scores[i] = input.nextDouble();
}
return scores;
}
public static void printScore(double [] scores){
for (int i = 0; i < scores.length; i++) {
System.out.println("第" + (i + 1) + "个人的成绩为：" + scores[i]);
}
}
}
可变长参数;
概念：可接收0个或者多个同类型实参，个数不限，使用方式与数组相同。
要求：只能在形参列表的末尾 形参列表中只能存在一个可变长参数
package com.atguigu.demo.demo2;
/**
* 可变长参数：
* 概念：可接收0个或多个同类型实参，个数不限，使用方式与数组相同
* 要求：只能在形参列表的末尾，形参列表只能存在一个可变长参数
*/
public class Test4 {
public static void main(String[] args) {
add();
}
public static int add(int...array){
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum+=array[i];
}
return sum;
}
}
10.面试题：值传递和“引用传递”的区别
面试题：值传递和"引用传递"的区别？
- java中都属于值传递，当我们传递引用数据类型时，依然属于数据传递，只不过这个值就是一个引用|地址（代表地址的哈希值）；
- 值传递,基本数据类型属于值传递，传递的是值本身的副本|拷贝 在方法中对变量进行操作不会影响原变量；
- “引用传递”，引用数据类型，属于引用传递，传递的是地址，在方法中队参数进行操作会影响原变量；
- String类型属于特殊的引用数据类型 作为参数传递不会改变原来的变量；
package com.atguigu.demo.demo3;
/**
* 面试题：值传递和“引用传递”的区别？
* 1.java中都属于值传递，当我们传递引用数据类型时，依然是数值传递，只不过这个值就是一个引用（地址|代表地址的哈希值）
* 2.值传递：基本数据类型，属于值传递，传递的是值本身的一个拷贝|副本，在方法中对变量进行操作不会影响原变量。
* 3.String类型属于特殊的引用类型，作为参数传递不会改变原变量的值
*/
public class Test1 {
public static void main(String[] args) {
int a = 10;
m1(a);
System.out.println("main方法中a的值为：" + a);
System.out.println("-----------------------------------------------------");
int [] arr1 = {1,2,3,4,5};
m2(arr1);
System.out.println("main方法中打印arr1元素值");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + "\t");
}
System.out.println();
System.out.println("-----------------------------------------------------");
String str = "abc";
m3(str);
System.out.println(str);
}
//值传递
public static void m1(int num){
num += 10;
System.out.println("m1方法中num的值为：" + num);
}
//引用传递
public static void m2(int [] nums){
for (int i = 0; i < nums.length; i++) {
nums[i]++;
System.out.println("m2方法中打印元素值：" + nums[i]);
}
System.out.println("m2方法执行完毕");
}
//String传递
public static void m3(String str){
str += "hello";
}
}
11.数据结构
线性表 数组、链表(单向链表，双向链表)
树：二叉树、二叉查找树、二叉平衡查找树、红黑树
数据结构参考网站:https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
12.排序
12.1冒泡排序
冒泡排序：两个相邻的元素来比较，如果条件成立则交换位置
外层循环 n - 1
内层循环 n - 1 -i
package com.atguigu.demo.demo4;
/**
* 冒泡排序：两个相邻的元素来比较，如果条件成立则交换位置
* 外层循环 n - 1
* 内层循环 n - 1 -i
*/
public class Test1 {
public static void main(String[] args) {
int [] array1 = {123,111,132,89,141,99,105,80};
// 外层循环控制比较的轮数 长度 - 1 (n- 1)
// 内层循环控制每一轮比较的次数 最多的一次是长度-1 后续每轮依次递减1
for (int i = 0; i < array1.length-1; i++) {
for (int j = 0; j < array1.length-1-i; j++) {
if(array1[j]>array1[j+1]){
int temp=array1[j+1];
array1[j+1]=array1[j];
array1[j]=temp;
}
}
}
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i]+"\t");
}
System.out.println("程序结束");
}
}
12.2选择排序
选择排序：选择排序使用一个固定位置的元素，依次与其他元素进行比较。如果 遇到需要交换位置的元素，先不交换
等待一轮比较完毕以后，统一换一次位置
外层循环充当比较的元素A 从第一个开始 到倒数第二个元素
内层循环充当比较的元素B 从第二个开始 后续每一轮 后延一位 直到最后一位
package com.atguigu.demo.demo4;
/**
* 选择排序：选择排序使用一个固定位置的元素，依次与其他元素进行比较。如果遇到需要交换位置的元素，先不交换
* 等待一轮比较完毕以后，统一换一次位置
* 外层循环充当比较的元素A 从第一个开始 到倒数第二个元素
* 内层循环充当比较的元素B 从第二个开始 后续每一轮 后延一位 直到最后一位
*/
public class Test2 {
public static void main(String[] args) {
int [] array1 = {123,111,132,89,141,99,105,80};
// 外层循环充当比较的元素A 从第一个开始 到倒数第二个元素
//内层循环充当比较的元素B 从第二个开始 后续每一轮 后延一位 直到最后一位
for (int i = 0; i < array1.length-1; i++) {
int index =i;
for (int j = i; j < array1.length ; j++) {
if(array1[index]>array1[j]){
index = j;
}
}
if(index!=i){
int temp = array1[index];
array1[index]=array1[i];
array1[i]=temp;
}
}
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i]+"\t");
}
}
}
标签：Java,int,day07,System,学习,数组,println,public,out 来源： https://www.cnblogs.com/muamuspace/p/16475337.html