2021-02-03

最新推荐文章于 2022-03-21 10:20:49 发布

summm153

最新推荐文章于 2022-03-21 10:20:49 发布

阅读量2.4w

点赞数

本文链接：https://blog.csdn.net/summm153/article/details/113615606

版权

Scanner类

next()

一定要读取到有效字符后才可以结束输入
对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
对输入有效字符后才将其后面输入的空白作为分隔符或者结束符
不能得到带有空格的字符串

nextLine()

以回车作为结束符，会返回输入回车之前的所有字符
可以获得空白

Java方法

方法是语句的集合，他们在一起执行一个功能
方法包含于类或对象中

设计方法的原则

方法的本意是功能块，一个方法只能完成一个功能

方法的重载

重载在一个类中，有相同的函数名称，但形式参数不同的函数

方法的重载的规则

方法名称必须相同
参数列表必须不同（个数、类型、参数排列顺序）
方法的返回类型不可以作为判断是否是同一方法的标准

命令行传参

希望运行一个程序时再传递给他消息，这要依靠传递命令行参数给main()函数实现

可变参数

在方法声明中，在指定参数类型后加三个 .

一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在它前边声明。

public class Demo1 {
    public static void main(String[] args){
        Demo1 sum=new Demo1();
        sum.text(15,12,18,49,4,498,789,45);
    }
    public void text(int... i){  //查找最小值
        int a=0;
        for(int j=0;j<i.length;j++)
        if(i[a]>i[j])
            a=j;
        System.out.println(i[a]);
    }
}

数组

java内存

堆存放new的对象和数组可以被所有的线程共享，不会存放别的对象引用
栈存放基本变量类型 (会包含这个基本类型的具体数值) 引用对象的变量（会存放这个引用在堆里边的具体地址）
方法区可以被所有的线程共享包含了所有的class 和static变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GjoUNVJt-1612344235364)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20210203104357799.png)]

数组的初始化

静态初始化创建+赋值

int[] a ={1,15,23,4,65}; //声明后会自动分配内存，分配后内存不变

动态初始化

int[] a = new int[10]; //会默认赋值

数组的四个基本特点

其长度是确定的，数组一旦被创建，它的大小就是不可以改变
其元素必须是相同类型，不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他类型对象类型，数组对象本身是在堆中的。

Arrays类

冒泡排序

public static void sort(int[] a){ //冒泡排序，从小到大
    int temp=0;//临时变量
    for(int i=0;i<a.length;i++)
    {
        change=0;
        for(int j=0;j<a.length-1-i;j++)
            if(a[j+1]<a[j])
            {  temp=a[j+1];
               a[j+1]=a[j];
             a[j]=temp;
             change=1;
            } 
        if(change==0)
            break;
    }
}

稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组

[0]	a	b	c
[1]
[2]
[3]
[4]

a表示数组有几行 b表示数组有几列 c表示数组有几个数据
接下来每一行表示每个数据所在行数，所在列数以及该数据的值

package com.chen.first;
import java.util.ArrayList;
import java.util.Arrays;
public class Demo1 {
    public static void main(String[] args){
       int [][] a= new int [11][11];
       a[2][3]=1;
       a[3][4]=2;
       int num=0;
        for(int[]ints:a)
        {  for(int b:ints) {
            System.out.print(b+"\t");
        }
            System.out.println();
        }
       for(int[]ints:a)
       {  for(int b:ints) {
           if(b!=0)
               num++;
          }
       }
       System.out.println("有效元素为"+num+"个");
       System.out.println("稀疏数组:");
       int[][] array2=new int[num+1][3];   //创建稀疏数组
       array2[0][0]=a.length;
       array2[0][1]=a[0].length;
       array2[0][2]=num;
       num=1;
       for(int i=0;i<a.length;i++)
           for(int j=0;j<a[i].length;j++)
               if(a[i][j]!=0)
               {
                   array2[num][0]=i;
                   array2[num][1]=j;
                   array2[num][2]=a[i][j];
                   num++;
               }
       for(int[] ints:array2) {
           for (int b : ints){
               System.out.print(b+"\t");
           }
           System.out.println();
       }
    System.out.println("稀疏数组还原:");
       int i=array2[0][0];
       int j=array2[0][1];
       int d=array2[0][2];
       int [][] array3=new int [i][j];
       for(int m=1;m<=d;m++)
       {
           array3[array2[m][0]][array2[m][1]]=array2[m][2];
       }
        for(int[]ints:array3)
        {  for(int b:ints) {
            System.out.print(b+"\t");
        }
            System.out.println();
        }
    }
}