方法与数组_java_大全(学习笔记ing)

一.方法

1.简介

方法是实现特定功能的代码段的封装，在需要时可以多次调用方法来完成相应的功能，实现代码的复用。

2.  用法

(a)定义方法

语法： 

修饰符 返回值类型 方法名(参数){
       // 方法体
   }

说明：

   - 修饰符：对方法的修饰，public static暂且认为是固定写法
   - 返回值类型：方法执行后的返回值的类型，如果没有返回值则指定为void
   - 方法名：采用驼峰命名法，一般使用动词
   - 参数：执行方法时所需要的信息，参数由参数类型和参数名组成，以空格隔开，参数可以有多个，多个参数之间以逗号隔开。

2. 调用方法

语法：
   方法名(参数);

说明：

- 如果方法有参数，则必须传递，且参数数量、类型必须一致
- 如果方法有返回值，则可以接收返回值并保存到变量中

3. 递归

方法自己调用自己，称为递归，该方法称为递归方法

二、数组

1. 数组简介

数组是用来存储相同数据类型的一组数据。

- 声明一个变量就是在内存中分配一块合适的空间；
- 声明一个数组就是在内存中分配一串连续的空间；

数组的四要素：

- 数组名称：用于区分不同的数组
- 数组元素：向数组中存放的数据
- 元素类型：数组元素的数据类型
- 元素下标：数组元素的编号，也称为索引，从0开始，通过下标来访问数组中的元素

注：数组通过下标来访问数组中的元素，hashMap通过元素访问下标。

2. 基本用法

(1)声明数组

   指定元素的类型

   数据类型[] 数组名称;或数据类型  数组名称[];

(2)分配空间

   指定数组长度/大小，即分配几个连续的空间

   数组名称 = new 数组类型[大小];

注意二选一：1.开辟地址空间长度 2.定义数组后直接赋值,一定不能写长度

*数组长度一旦指定,则无法改变,不能增加长度,只能重新创建一个新数组

String advantages[]=new String[2];
String[] advantages={"draw","sing"};

(3)为数组赋值

   向数组中添加元素

   数组名称[下标]=值;

注意：输出数组名直接返回首地址 需要加索引进行访问

System.out.println(advantages);
System.out.println(Arrays.toString(advantages));
//Arrays.toString(数组名) 把数组以字符串"[]"包含数组元素的形式输出

(4)访问数组元素

   数组名称[下标]

3. 动态赋值

循环获取用户输入的数据，动态为数组中的元素赋值；已知数组长度，可得循环次数；

String[] talkShow=new String[2];
Scanner input=new Scanner(System.in);
		
for(int i=0;i<talkShow.length;i++){
	System.out.println("请输入您的第"+(i+1)+"句脱口秀演讲词：");
	talkShow[i]=input.next();
	}

4. 增强for循环

增强for循环 亦foreach循环 用来对集合进行遍历操作(foreach本身并不是java中的关键字)
for(元素类型 循环变量：集合）{}

int[] single={11,22,33};
		for(int e:single){
			System.out.println(e);
		}

5. 默认值

数组中的元素有默认值，如果为数组分配了内存空间，那么系统会为数组元素指定默认值，该默认值与数组的数据类型有关。

数据类型	默认初始值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	.\u.000
boolean	false
引用类型(类,接口)	null        (eg:String)

6. 常用错误

(a)当索引<0或>=数组的长度 报错 java.lang.ArrayIndexOutOfBoundsException
(b)定义数组时直接赋值{11,22}/分配数组长度 [10] 一定二选一

1.越界
error1[-1]=2;

2.既然指定了长度 只能单个赋值
int[] error2=new int[2];
error2={11,22}; 

3.局部变量不赋值会报错 但数组不赋值会给默认值
int a;
System.out.println(a);

int[]initial=new int[2];
initial[0]=11;
System.out.println(initial[1]);

三、数据存储方式

1. 内存分类

Java中内存的分类：栈内存、堆内存

- 栈的存取速度比堆要快
- 栈内存要小于堆内存

栈区:   栈也叫栈内存，基本类型的变量和对象的引用变量都是在函数的栈内存中分配。主管Java程序的运行，是在线程创建时创建，它的生命期是跟随线程的生命期，线程结束栈内存也就释放，对于栈来说不存在垃圾回收问题，只要线程一结束该栈就结束，生命周期和线程一致，是线程私有的。存取速度比堆要快，仅次于寄存器，栈数据可以共享，当超过变量的作用域后，Java会自动释放掉该变量,内存空间可以立即被另作他用。

堆区: 由new等指令创建的对象和数组，存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)；jvm只有一个堆区被所有线程共享。

方法区:被所有线程共享，所有字段和方法字节码，以及一些特殊方法如构造函数，接口代码也在此定义，又叫静态区，跟堆一样，被所有的线程共享。在整个程序中永远唯一的元素，方法区包含所有的class和static变量。 

Flower f=new Flower();
		
Flower f;
f=new Flower();
		
对象的引用变量:f    对象：new出来的结果
new出来的类初始化后（处于堆中）指向对象的引用变量（栈中起名）

<借鉴其他博客的比喻！>
（1）一个对象引用可以指向0个或1个对象（一根绳子可以不系汽球，也可以系一个汽球）
（2）一个对象可以有多个引用指向它（可以有N条绳子系住一个汽球）。

2. 数据类型

根据存储方式的不同，主要为两种：

(a)基本数据类型（8种）

byte、short、int、long、float、double、char、boolean

定义方式：数据类型 变量名=值;

(b)引用数据类型

除了基本数据类型和null以外的其他数据类型，如：String、数组、类、接口......

定义方式：类型名 变量名=new 类型名()

注：null是一种特殊的数据类型，表示空，null是所有引用数据类型的默认值

String类型比较特殊，因为特别常用，所以JVM对其做了优化

3. 数据在内存中的存储方式

- 基本数据类型的值和引用数据类型的名称，都是存储在栈内存中
- 引用数据类型的值，存储在堆内存中

数组的首地址存放在栈中，指向堆中具体的值

4. 值传递和引用传递

对于基本数据类型，传递的是值

对于引用数据类型，传递的是地址

四、二维数组

二维数组可以认为是特殊的一维数组 一维数组中的每个元素又是一个一维数组；
二维数据分类：规则的二维数组(数组形状规则)  不规则的二维数组；

方法一：定义数组同时为其赋值
int[][] array=new int[][]{{1,2},{3,4},{5,6},{7,8}};
方法二：定义数组同时为其赋值 分配空间 给长度 后面单独赋值
double[][] money;
money=new double[1][2];
money[0][0]=12.1;
money[0][1]=17.2;
		
		
System.out.println(array.length);//行
System.out.println(array[0].length);//列
		
for(int i=0;i<array.length;i++){
	for(int j=0;j<array[i].length;j++){
		System.out.print(array[i][j]+"\t");
	}
    System.out.println("");
}

方法一：二维直接赋值		
int[][] a={{1},{2,3},{4,5,6}};

方法二：给定一个行 一维数组的每个元素又是一个一维数组
		int[][] c=new int[3][];
		c[0]=new int[1];
		c[1]=new int[2];
		c[2]=new int[3];

		c[0][0]=111;
		c[1][0]=222;
		c[1][1]=333;
		c[2][0]=666;
		c[2][1]=777;
		c[2][2]=888;

不规则数组行列不一样 无法直接输出
		for(int i=0;i<c.length;i++){
			for(int j=0;j<c[i].length;j++){
				System.out.print(c[i][j]+"\t");
			}
			System.out.println("\n");
		}
				
增强for循环的时候 一维二维不一样
		int[] b={1,2,111,222};
		
		for(int e:b){
			System.out.println(e);
		}
		
		for(int[] e:a){
		System.out.println(Arrays.toString(e));
//		无法直接输出（e）
        }

        for(int[] e:a) {
			    for(int d:e){
				    System.out.print(d);
		    	}
			    System.out.println();
		 }

五、冒泡排序

排序算法很多：冒泡排序 快速排序 选择排序 插入排序
冒泡排序原理：依次比较相邻的两个元素 如果顺序有出错误则交换位置、
结论：如果有n个数字 则需要比较n-1轮 (每次两两比较后 能确定第一大的)； 每一轮两两比较的次数n-m，m表示第几轮；
eg:10个数 比9轮 第一轮九次（第一大已知） 第二轮八次（第二大已知）...     

int[] a={10,80,40,70,30,20,6};
		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;
					temp=a[j+1];
					a[j+1]=a[j];
					a[j]=temp;
					}
				}
			}
		System.out.println(Arrays.toString(a));

六、Arrays工具类

java.util.Arrays类提供了操作数组的一些方法，可以直接使用；

int[] repeat={22,55,33,99,66,88,44,11,00};
		
toString()将数组转化为字符串
		System.out.println(Arrays.toString(repeat));

sort() 升序排序
		Arrays.sort(repeat);
		System.out.println(Arrays.toString(repeat));
		
fill() 填充/初始化    
//		Arrays.fill(a, val);
		Arrays.fill(repeat, 666);
		System.out.println();
		
复制数组错误方法 直接赋值是把堆里面的地址赋值过去 共用一块存储空间
		int[]repeat2=repeat;
		
常规方法复制数组 循环
		int[]repeat3=new int[repeat.length];
		for (int i = 0; i < repeat3.length; i++) {
			repeat3[i]=repeat[i];
		}
		repeat3[0]=123;
		System.out.println("repeat是"+Arrays.toString(repeat));
		System.out.println("repeat3是"+Arrays.toString(repeat3));
		
		
copyOf复制数组 返回复制后的新数组(不需要提前创建新数组)
//		Arrays.copyOf(original, newLength)
		int[]repeat4=Arrays.copyOf(repeat, repeat.length);
		System.out.println("repeat4是"+Arrays.toString(repeat4));
		
		
copyOfRange复制数组中指定范围内的元素
//		Arrays.copyOfRange(original, from, to)
		int[] repeat5=Arrays.copyOfRange(repeat, 1, 4);
		System.out.println("repeat5是"+Arrays.toString(repeat5));
		
		
		/*System类的arraycopy（）方法  ctrl+copyOfRange可以进一步查看
		注：Arrays类的copyOf和copyOfRange 本质上就是调用的System.arraycopy()
		System.arraycopy(src, srcPos, dest, destPos, length);
		从索引为1的位置开始复制repeat数组 复制3个 放到repeat5数组索引为2的位置
		*/
System.arraycopy()
		System.arraycopy(repeat, 1, repeat5, 2, 3);

 七、不定长参数

语法："数据类型... 参数名" 表示不定长参数，也称为可变长参数

特点：实质上就是数组

(a) 只能是方法的最后一个参数
(b)调用方法时参数的个数任意
(c)一个方法最多只能有一个可变长参数
(d)本质上是一种特殊的数组，只能作为方法的形参

相当于把刚开辟了的空间 当作实参传过去了先 要保证两个都要传
		m1(2,new String[]{"11","22","33"});

传值比较方便 可以直接写
		m2(90,"aaa","bbb","ccc");
		
也可以传递一个你刚开辟的空间的数组  赋没赋值都行 引用类型默认值都为null
		m2(100,new String[2]);
	}
	
	public static void m1(int a,String[]array){
		System.out.println("a="+a);
		System.out.println(array);
		System.out.println(Arrays.toString(array));
	}
	
	public static void m2(int a,String...args){
		System.out.println("a="+a);
		System.out.println(args);
		System.out.println(Arrays.toString(args));
实质上就是数组

练习

int[]a={86,70,13,35,90,66,89};

Array.copyOf()用于复制指定的数组内容以达到扩容的目的
int[]b=Arrays.copyOf(a,(a.length+2));

左闭右开
int[]d= Arrays.copyOfRange(a,0,2);

输出
System.out.println(Arrays.toString(a));//如果直接输入a则是数组的首地址

排序
int max=a[0];
		for(int i=0;i<a.length;i++){
			if(a[i]>max){
				max=a[i];
			}
		}
		int temp;
		temp=a[0];
		a[0]=max;
		System.out.println(Arrays.toString(a));		
		System.out.println("——————————————————————————————————");
//		确实是找到了最大值 但要把原来a[0]和最大值的位置(位置即索引)调换
	
		int maxIndex=0;
		for(int i=0;i<a.length;i++){
			if(a[maxIndex]<a[i]){
				maxIndex=i;
			}
		}
		
		int t;
		t=a[0];
		a[0]=a[maxIndex];
		a[maxIndex]=t;
		System.out.println(Arrays.toString(a));
		System.out.println("——————————————————————————————————");

这是一边看视频一边学习的笔记-借用了一些老师的笔记内容-如有侵权，通知删除！

新手小白学习之路~~~