javase-javabase-210126-02
- JavaDoc Scanner对象
- 重载 可变参数 递归
- Java内存 数组 Arrays类
JavaDoc
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
/**
* @author baiguangyi
* @version 1.0
* @since 1.8
*/
public class Doc {
public static void main(String[] args) {
}
/**
*
* @param name
* @return
*/
public String aaa(String name){
return name;
}
}
生成JavaDoc文档
-
通过命令行生成
-
javadoc 参数 java文档
图片丢失
-
-
使用IDEA生成
图片丢失
Scanner对象
Scanner类的 next() 和 nextLine() 方法获取输入的字符串
再读取前，一般需要使用 hasNext() 和 hasNextLine() 判断是否还有输入的数据
public class Test01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入：");
if(scanner.hasNext()){
String s=scanner.next();
/*
next()
1.一定读取到有效的字符后才结束
2.对输入有效字符之前遇见的空白，next()方法 会自动将其去掉
3.只有输入有效的字符后才将其后面输入的空白 作为分隔符或结束符
4.next()不能得到带有空格的字符串
*/
System.out.println(s);
}
scanner.close();//关于流的需要关闭，否则会浪费资源
}
}
public class Test02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入：");
if(scanner.hasNext()){
String s=scanner.nextLine();
/*
nextLine()
1.以Enter为结束符，nextLine()方法返回的是 输入回车之前的所有字符
2.可以获取空白
*/
System.out.println(s);
}
scanner.close();//关于流的需要关闭，否则会浪费资源
}
}
重载
相同的函数名称，但形参不同
重载规则：
- 方法名必须相同
- 参数列表必须不同（个数，类型，参数排列顺序不同等）
- 方法的返回类型可以相同，也可不同
可变参数
JDK1.5开始，Java支持传递同类型的可变参数给一个方法
在方法声明中，制定参数类型后加一个省略号（…）
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声明
public class Test01 {
public static void main(String[] args) {
Test01 test01 = new Test01();
test01.test(1);//1
Test01 test011 = new Test01();
test01.test2(4,5,6,7);//4,5,6,7
}
public void test(int... i){
System.out.println(i[0]);
}
public void test2(int... i){
System.out.println(i[0]);
System.out.println(i[1]);
System.out.println(i[2]);
System.out.println(i[3]);
}
}
public class Test02 {
public static void main(String[] args) {
//调用可变参数的方法
printMax(5,6,9,8,7,11,32,99);//99
printMax(new double[]{5,6,99,11});//99
printMax();//No argument passed
}
public static void printMax(double... numbers){
if(numbers.length==0){
System.out.println("No argument passed");
return;
}
double result=numbers[0];
//排序
for (int i = 1; i < numbers.length; i++) {
if(numbers[i] > result){
result=numbers[i];
}
}
System.out.println("最大值是: "+result);
}
}
递归
-
自己调用自己呗！！！
-
递归结构两个部分
- 递归头：什么时候不调用自身方法。没有头，将陷入死循环
- 递归体：什么时候需要调用自己
public class Test03 { public static void main(String[] args) { System.out.println(f(5));//120 } public static int f(int n){ if(n==1){ return 1; }else{ return n*f(n-1); } } }递归也有弊端，程序深度很大，程序会崩溃
Java内存
- 堆
- 存放new的对象和数组
- 可以被所有的线程共享，不会存放别的对象的引用
- 栈
- 存放基本变量类型（包括含这个基本类型的具体数值）
- 引用对象的变量（会存放这个引用在堆里面的具体地址）
- 方法区
- 可以被所有的线程共享
- 包含了所有的class和static变量
数组
-
静态初始化数组
int[] arr1={1,2,3,4,5,6};
-
动态初始化数组
int[] arr2=new int[5];
特点：
- 长度固定，一旦被创建，大小不可变
- 其元素必须是相同类型
- 数组中元素可以是任意数据类型
- 数组变量属于引用类型，数组也可以看作是对象，数组中每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，所以数组无论保存原始类型还是其他对象类型，数组对象本省是在堆中的
多维数组
public class Test04 {
public static void main(String[] args) {
int[][] arr1=new int[6][6];
int[][] arr2={{1,2,3,4},{5,6,7},{8,9},{10}};
System.out.println(arr2[0][0]);//1
}
}
稀疏数组
当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
也就是记录下标和值
处理方式：
-
记录数组一共有几行几列，有多少个不同值
-
把具有不同值得元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
如下如图一：6行7列，有8个有效值
如下图二：11行，11列，2个有效值
[0] 11 11 2
[1] 1 2 1
[2] 2 3 2
public class Test01 {
public static void main(String[] args) {
//1.创建一个二维数组
int[][] arr1=new int[11][11];
//2.给数组赋值
arr1[1][2]=1;
arr1[2][3]=2;
System.out.println("原始数组：");
//3.打印数组
for (int i=0;i<arr1.length;i++){
for (int j=0;j< arr1.length;j++){
System.out.print(arr1[i][j]+"\t");
}
System.out.println();
}
System.out.println("================================================");
//生成稀疏数组
//1.获取有效个数
int sum=0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1.length; j++) {
if(arr1[i][j]!=0){
sum++;
}
}
}
// System.out.println("有效元素有"+sum+"个");//2
//2.创建一个稀疏数组
int[][] arr2=new int[sum+1][3];
arr2[0][0]=11; //存原始数组有几行
arr2[0][1]=11; //存原始数组有几列
arr2[0][2]=sum; //存原始数组有几个有效元素
//3.遍历二维数组，将非零的元素存放在稀疏数组中
int count=0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1.length; j++) {
if (arr1[i][j]!=0){
count++;
arr2[count][0]=i; //存横坐标
arr2[count][1]=j; //存纵坐标
arr2[count][2]=arr1[i][j];
}
}
}
//4.输出稀疏数组
System.out.println("稀疏数组：");
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2.length; j++) {
System.out.print(arr2[i][j]+"\t");
}
System.out.println();
}
System.out.println("================================================");
//还原稀疏数组
System.out.println("还原稀疏数组");
//1.读取稀疏数组
int[][] arr3=new int[arr2[0][0]][arr2[0][1]];
//2.给元素还原值
for (int i = 1; i < arr2.length; i++) {
arr3[arr2[i][0]][arr2[i][1]]=arr2[i][2];
}
//3.打印还原数组
System.out.println("还原数组"); for (int[] ints : arr3){
for (int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
Arrays类
这是数组的工具类java.util.Arrays
Arrays类中的方法都是static静态方法，可以直接使用类名进行调用
常用功能：
- 给数组赋值： fill方法
- 给数组排序： sort方法，升序
- 比较数组： equals方法，对比数组元素是否相等
数组"); for (int[] ints : arr3){
for (int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
#### Arrays类
这是数组的工具类java.util.Arrays
Arrays类中的方法都是static静态方法，可以直接使用类名进行调用
常用功能：
- 给数组赋值： fill方法
- 给数组排序： sort方法，升序
- 比较数组： equals方法，对比数组元素是否相等
- 查找元素： binarySearch方法，对排序好的数组进行二分查找法
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
