大家好,又见面了,我是你们的朋友全栈君。
public class Demo01 {
public static void main(String[] args) {
//main就是一个方法————由java虚拟机调用
//void 是表示返回类型为空
int sum = add(1, 2); //1,2为实际参数
System.out.println(sum);
}
public static int add(int a,int b){
//a,b为形式参数
return a+b;
}
}
修饰符+返回值类型+方法名(参数类型 参数名){ 方法体 return }
return——不仅可以用于返回相应值,也可以用于终止方法
修饰符 ——告诉编译器如何调用该方法,定义了该方法的访问类型
main方法——一般要保持简洁干净,尽量把一些公共模块放到main外面
区分值传递和引用传递——Java中只有值传递——核心思想是:拷贝生成一份新的
[等待:下来再了解补充]
一般情况:写几个名字一样的方法(方法名必须相同),让它们的参数类型不同(一定不同),参数个数可以不同,参数顺序可以不同,方法体也可以不同。
在调用方法时,根据用户的输入的参数个数类型,调用对应的方法。
方法名必须相同,参数列表必须不同
在一个程序运行时才给他传递消息(动态传参),要靠传递命令行参数给main()方法实现。
public class Demo02 {
public static void main(String[] args) {
for (int i =0;i<args.length;i++){
System.out.println("args["+i+"]:"+args[i]);
}
}
}
此处命令行参数——String[ ] args 就是一个String类型的数组,args是数组名字,arguments的缩写,就是参数的意思。
命令行窗口操作如下 1.在命令行窗口进入文件所在目录进行编译(javac) javac 文件名.java 2.运行时要退回到src目录传递参数(cd… 可以返回上一级目录) java 文件名(带路径) 参数
输出结果: args[0]:this args[1]:is args[2]:kk
作用:避免方法重载太多次
public class Demo03 {
public static void main(String[] args) {
Demo03 demo03 = new Demo03(); //新建一个本类对象
//test方法的参数列表是可变的,所以可以传任意个参数
demo03.test(1,2,3);
// demo03.test(5);
// demo03.test();
}
public void test(int... i){
System.out.println(i[0]);
System.out.println(i[1]);
}
}
notes:
可变参数格式:
递归头:什么时候退出递归!如果没有头,将陷入死循环
递归体:一些指定操作+调用自身
public class Demo04 {
public static void main(String[] args) {
//阶乘
System.out.println(fac(5));
}
public static int fac(int n){
if (n==1) return 1;//———————————递归头
else return n*fac(n-1);
}
}
notes:
相同类型数据的有序集合
//数组类型[] 数组名 = 值
int[] nums; // ——————首选
int nums2[];
nums = new int[10];
获取数组长度 nums.length 获取字符串的长度s.length()
不赋值默认所有元素为0
声明和创建同时
int[] nums= new int[10]; ( 在IDEA中可以只写new int[10]按住alt+回车自动补全前面 )
此处出现的常见错误:访问数组下标越界 java.lang.ArrayIndexOutOfBoundsException
public class ArrayDemo02 {
public static void main(String[] args) {
//静态初始化——创建+赋值
int[] a ={
5,6,7,8}; //定义后,长度不可变
// 引用类型的数组,数组里放的是对象
Man[] mans={
new Man(),new Man()};
//动态初始化 (包含了默认初始化)
int[] b = new int[10]; //创建后所有默认值为0,需要赋值
b[0]=10;
}
}
class Man{
}
notes:
数组下标的合法区间是[0,length-1]
单行快速注释 ctrl+/
模块注释:选中,然后ctrl+shift+/
int[] arrays={
1,2,3,4,5};
for (int array : arrays) {
// 临时变量 : 需要遍历的数组
System.out.println(array);
}
public class ArrayDemo03 {
public static void main(String[] args)
{
int[] arrays={
1,2,3,4,5};
printArray(arrays);
}
//方法——打印数组 参数是数组
public static void printArray(int[] arrays)
{
for (int i=0;i<arrays.length;i++)
{
System.out.print(arrays[i]+" ");
}
}
}
package methodStudy;
public class ArrayDemo03 {
public static void main(String[] args){
int[] arrays={
1,2,3,4,5};
int[] reverse= reverse(arrays);
printArray(reverse);
}
//方法——打印数组 参数就是数组
public static void printArray(int[] arrays){
for (int i=0;i<arrays.length;i++){
System.out.print(arrays[i]+" ");
}
}
//反转数组的方法
public static int[] reverse(int[] arrays){
int[] result= new int[arrays.length];
for(int i=0,j=result.length-1;i<arrays.length;i++,j--){
result[j]=arrays[i];
}
return result; //返回翻转后的新数组
}
}
数组里边是数组
public static void main(String[] args) {
int[][] array={
{
1,2},{
1,3},{
2,5},{
53,6}};
System.out.println(array.length); //输出4
System.out.println(array[0].length); //输出2
//遍历几维数组就,需要几重循环
for (int i = 0; i <array.length ; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]+" ");
}
}
}
来源 java.util.Arrays
//Arrays类的一些常用方法
public class Demo05 {
public static void main(String[] args) {
int[] a={
1,5,3,48,6,9656,65,6};
System.out.println(a);
//直接打印数组a,是返回一个hashcode——[I@1b6d3586
//打印输出数组——列表形式
System.out.println(Arrays.toString(a));
//给数组排序
Arrays.sort(a);//升序
System.out.println(Arrays.toString(a));
//填充覆盖数组
Arrays.fill(a,0); //将数组a中的元素全部覆盖为0
System.out.println(Arrays.toString(a));
//指定范围的填充
Arrays.fill(a,2,5,0);
//将数组a中的2-5位置填充为0(不包含又边界,即a[5])
System.out.println(Arrays.toString(a));
}
}
原理: (升序冒泡)每一轮选出一个最大的,两层循环,外层冒泡轮数,里层依次比较
步骤:
import java.util.Arrays;
public class Demo06 {
public static void main(String[] args) {
int[] a ={
50,3,65,35,85,43,1};
int[] sort=bubbleSort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] bubbleSort(int[] array){
int temp=0;
//外层循环,判断要走多少次
for (int i = 0; i <array.length-1 ; i++) {
//为什么array.length要-1?因为如果有六个数
//只要确定后五个数位置,第一个数也就确定了
//内层循环:比较————调换位置
for (int j = 0; j <array.length-1-i ; j++) {
//为什么array.length-1还要再减去i?
// 因为在第i轮时,说明后面已经有i个位置已经确定了
//比如在第0轮,没有位置被确定,就是-0
//第0轮结束后,在第1轮时有1个位置被确定,所以-1
if(array[j]>array[j+1]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
return array;
}
}
提问:如果原序列本来就是有序的,那每一轮的比较都是在浪费时间,如何优化呢? 这就涉及到了八大排序算法问题。后续总结。
对于一个空数据较多的矩阵,需要压缩存储节省空间
步骤:
package methodStudy;
public class Demo08 {
public static void main(String[] args) {
// 创建二维压缩数组11*11
// 0:没有棋子 1:黑棋 2:白棋
int[][] array1=new int[11][11];
array1[1][2]=1;
array1[2][3]=2;
System.out.println("原始数组如下:");
for (int[] ints : array1) {
//遍历二维数组第一层
for (int anInt : ints) {
//遍历二维数组第二层
System.out.print(anInt+"\t");
}
System.out.println();
}
// 转换为稀疏数组
//1.获取有效值的个数
System.out.println("=================================");
int count=0;
for (int i = 0; i <11 ; i++) {
for (int j = 0; j <11 ; j++) {
if (array1[i][j]!=0) count++;
}
}
System.out.println("有效值个数为:"+count);
//2.创建稀疏数组
int[][] array2=new int[count+1][3];
//设置第一行元素
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=count;
//3.遍历原数组,找到有值的元素,把其位置信息和值赋给稀疏数组
int count2=0;
for (int i = 0; i <11 ; i++) {
for (int j = 0; j <11 ; j++) {
if (array1[i][j]!=0) {
count2++;
array2[count2][0]=i;
array2[count2][1]=j;
array2[count2][2]=array1[i][j];
};
}
}
//4.输出稀疏数组
for (int[] ints : array2) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
// 由稀疏数组还原成原数组
System.out.println("=================================");
System.out.println("还原数组为:");
//1.读取稀疏数组第一行的两个元素(原数组的行数和列数),新建二维数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.还原其中有值的元素
for (int i = 1; i <array2.length ; i++) {
array3[array2[i][0]][array2[i][1]]=array2[i][2];
}
//3.打印还原后的数组array3
for (int i = 0; i <array3.length ; i++) {
for (int j = 0; j < array3[i].length; j++) {
System.out.print(array3[i][j]+"\t");
}
System.out.println();
}
}
}
输出结果:
输出原始数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
=================================
有效值个数为:2
11 11 2
1 2 1
2 3 2
=================================
还原数组为:
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
发布者:全栈程序员栈长,转载请注明出处:https://javaforall.cn/168487.html原文链接:https://javaforall.cn