java入门浙江大学版-bilibili（二）

最新推荐文章于 2022-09-09 11:41:30 发布

蘑菇屋

最新推荐文章于 2022-09-09 11:41:30 发布

阅读量388

点赞数

分类专栏： Java 读书笔记文章标签： java 浙江大学

本文链接：https://blog.csdn.net/weixin_43220058/article/details/86559150

版权

读书笔记同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

Java

2 篇文章 0 订阅

订阅专栏

#bilibilijava

文章目录

*** 2018-11-5 23:00… bilibili 浙江大学 java入门 4-2 循环控制-2***
*** 2018-12-03 23:00… bilibili 浙江大学 java入门 7-1 ***

-4 本地变量
定义在函数内部的变量都是本地变量

###7-1-5 块的含义

块就以为着大括号

使用标号“OUT:” 在内层循环中添加break OUT,那么break的就是out的循环体，并不是内循环体。

println 按行输出
print 在同行输出
printf 使用浮点数输出

调试运行的时候：
step over 一步步来
step into 进入到函数中
step return

hanshu zhong

for(a=1;a<0;a++)
初始值；循环得以继续的条件；循环中所做的操作

4-2循环控制-3-逻辑运算

优先级：！非 > &&与 > || 或
因为优先级：！age>20 :这里面的！优先级大于“>”

4-3循环计算-1

double 浮点数也就是小数

习题1-公式计算f(n)=1+1/2+1/3+1/4+…

package bilibilijava;
import java.util.Scanner;
//f(n)=1+1/2+1/3+1/4+...
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int n = in.nextInt();
	double sum = 0.0;
	for (int i =1 ;i<=n;i++)
	{
		sum += 1.0/i;//浮点数所以要用小数点0.0,1.0
	}
	System.out.println(sum);
	System.out.printf("%.2f",sum);
}
}

output
100
5.187377517639621
5.19

习题2-公式计算f(n)=1-1/2+1/3-1/4+…

//f(n)=1-1/2+1/3-1/4+...
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int n = in.nextInt();
	double sum = 0.0;
	//int sign = 1; //可以使用 sign=-sign
	for (int i =1 ;i<=n;i++)//i++是该循环每次循环会用的表达式
	{
		if (i%2==0)//偶数
			sum -= 1.0/i;//浮点数所以要用小数点0.0,1.0
		else
			sum += 1.0/i;
	}
	System.out.println(sum);
	System.out.printf("%.2f",sum);
}
}

习题3-求最大公约数

方法1：for循环

//求最大公约数，输入ab两个数，求最大公约数
//输入： 12 18
//输出：6
//方法1
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int a = in.nextInt();
	int b = in.nextInt();
	int rns=1;//表达结果，也就是最大公约数
	for(int i = 2; i<=a && i<=b;i++)//&&并且
		if(a%i ==0 && b%i == 0)
			rns=i;
	System.out.println(a+"和"+b+"的最大公约数是"+rns);
}
}

方法2：辗转相除法

//方法2 欧几里德法和辗转相除法
//(1)如果b=0,计算结束，a就是最大公约数---可以用while
//(2)否则，计算a/b的余数，让a=b,b=r
//(3)回到第一步
//a   b   r(余数)
//12  18  12
//18  12  6
//12  6   0
//6   0   end

public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int a = in.nextInt();
	int b = in.nextInt();
	int oa=a;//保留初始值数值
	int ob=b;
	System.out.println("a"+"---"+"b"+"---"+"r");
	while(b!=0)
	{
		int r = a%b;
		System.out.println(a+"---"+b+"---"+r);
		a=b;
		b=r;
	}
	System.out.println(oa+"和"+ob+"的最大公约数是"+ a);
}
}

5-1数组

数组就是容器，都是相同类型的，创建数组之后，没有办法在之后对大小进行改变。

<类型>[]<名字> = new <类型>[元素个数]
int[] grades = new int[100];
double[] averages = new double[20];
或以下方式
i=100
int[] grades = new int[i];

grades相当于数组的管理者

元素个数必须是整数，元素个数必须给出，元素个数可以是变量
编号从0开始，a[0]，可以读与写

数组名字.length,一般写在for循环的第二分号中，这是有可扩展性的循环代码。

习题4-投票统计

投票统计
写一个程序，输入数量不确定的【0,9】范围内的整数，统计每一种数字出现的次数，输入-1表示结束


//投票统计
//写一个程序，输入数量不确定的【0,9】范围内的整数，统计每一种数字出现的次数，输入-1表示结束
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int x;
	int[] nums = new int[10];//创建数组，其中长度10，每个位置分别表示每个数字的个数,默认数组中每个元素是零
	x = in.nextInt();
	while(x!=-1)
	{
		if(x>=0&&x<=9)//判断x在有效范围内
			nums[x]++;
		x = in.nextInt();//再次读取
	}
	for(int i = 0;i<nums.length;i++)//遍历数组，输出
		System.out.println(i+":"+nums[i]);
}
}

5-2数组计算

//数组-可扩展的代码
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int[] scores = {12,23,23,12,34,56,67,21};
	System.out.println(scores.length);
	for(int i=0;i<scores.length;i++)
	{
		System.out.print(scores[i]+" ");
	}
}
}

数组的管理者a，b。并不是数组的所有者，数组更新不受管理者影响

//数组-a b 同为数组的管理者，如果数组更新，那么遍历输出也更新，只是管理者不是所有者。
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int[] a={1,2,3,4,5};
	int[] b = a;
	for (int i=0;i<b.length;i++)
	{
	     b[i]++;
	}
	for (int i=0;i<a.length;i++)
	{
	System.out.print(a[i]);//23456
	}
	}
}

数组-ab同为管理者，但是如果数组中数值相同，并不是同一数组的管理者那么也为false

//数组-ab同为管理者，但是如果数组中数值相同，并不是同一数组的管理者那么也为false
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int[] a={1,2,3,4,5};
	int[] b = a;
	System.out.println("[b=a]:"+(a==b));//true
	int[] b1 = {1,2,3,4,5};
	System.out.println("[b1=a]:"+(a==b1));//false
}
}

数组拷贝方式

//数组拷贝
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int[] a={1,2,3,4,5};
	int[] b = new int[a.length];
	for(int i=0;i<b.length;i++)
	{
		b[i]=a[i];			
	}
	for(int i=0;i<b.length;i++)
	{
		System.out.print(b[i]);
	}
	}
}

数组判断相等方式

//数组判断里面的值是否相等,并不是管理者相等
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int[] a={1,2,3,4,5};
	int[] b = {1,2,3,4,5} ;
	boolean isEqu = true;
	//判断两数组是否相等
	for(int i=0;i<b.length;i++)
	{
		if(b[i]!=a[i])
		{
			isEqu = false;
			break;
		}
	}
		System.out.print(isEqu);//true
	}
}

寻找数组中某数x在data数组中的位置（效率不高）

//寻找数组中某数的位置
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	int x = in.nextInt();
	int[] data={1,2,3,4,5,8,9,10};
	int loc = -1;
	for(int i=0;i<data.length;i++)
	{
		if(x==data[i])
		{
			loc=i;
			break;
		}
	}
	if(loc>-1)
	{
		System.out.print(x+"的位置是第"+(loc+1)+"个");
	}
	else
	{
		System.out.print("数组中没有"+x);
	}
	}
}

3
3的位置是第3个

for-each 循环–遍历数组

比较适合该数组中有或没有这个数，而不是该数在哪个位置。
for(int k:data)
对于数组data中的每一个元素，循环每一轮，把它拿出来作为一个k
也就是第一轮k=data[0]，第二轮k=data[1]

5-2数组计算3

寻找前50个素数–优化解法

思路：首先先来一个50长度的空数组，然后将第一个数2放入进去，从3开始循环，运用索引指针从1开始，添加素数。
cnt表示这里面有多少个素数，也表示下一个应该写到哪里去

//寻找前50个素数--优化解法
//思路：首先先来一个50长度的空数组，然后将第一个数2放入进去，从3开始循环，运用索引指针从1开始，添加素数。
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
    int[] primes = new int[50];
    primes[0]=2;
    int cnt=1; //cnt表示这里面有多少个素数，也表示下一个应该写到哪里去
    MAIN_LOP:
    for(int x=3;cnt<50;x++)//从3往后找素数
    {
    	for(int i=0;i<cnt;i++)//遍历已知数组中的素数
    	{
    		if(x%primes[i]==0)
    		{
    			continue MAIN_LOP;//不用往下进行，从头从第一个for循环开始进行x++
    		}
    	}
    	primes[cnt++]=x;
    }
    for(int k:primes)
    {
    	System.out.print(k+" ");
    }
	}
}

寻找100以内的素数–优化解法2

寻找100以内的素数–优化解法2
//思路：构造n以内的素数表
//(1)令x为2
//(2)将2x 3x 4x直到ax<n的所有数都标记为非素数
//(3)令x为下一个没有被标记为非素数的数，重复2;直到所有数都尝试了完毕

//寻找100以内的素数--优化解法2
//思路：构造n以内的素数表
//(1)令x为2
//(2)将2x 3x 4x直到ax<n的所有数都标记为非素数
//(3)令x为下一个没有被标记为非素数的数，重复2;直到所有数都尝试了完毕
public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
    boolean[] isPrime = new boolean[100];//默认全部都是false,求一百以内的
//    for(boolean k:isPrime)
//    {
//        System.out.print(k+" ");
//    }
    for(int i=0;i<isPrime.length;i++)//先全都改成true
    {
    	isPrime[i]=true;
    }
    System.out.println(" ");//换行
    for(int i=2;i<isPrime.length;i++)//
    {
    	if(isPrime[i])//true的时候
    	{
    		for(int k=2;i*k<isPrime.length;k++)//倍数k
    		{
    			isPrime[i*k]=false;//如果有倍数的关系，那么改成false
    		}
    			
    	}
    }
    for(int i=0;i<isPrime.length;i++)//遍历现在的数组，查找到所有的true,也就是所有的素数。
    {
    	if(isPrime[i])
    	{
    		System.out.print(i+" ");
    	}
    }

//    for(boolean k:isPrime)
//    {
//        System.out.print(k+" ");
//    }
}
}

5-2数组计算4

二维数组的遍历一定是两层循环

int[][] a ={
{1,2,3,4},
{1,2,3},
};

注意：
1.每行一个｛｝，逗号分隔
2.最后的逗号可以存在可以不存在
3.如果省略，表示补零

tic-tac-toe游戏-九宫格棋子输赢

//九宫格棋子输赢
//规则：三行三列三对角线三反对角线如果全是X(1)或者O(0)，那么胜出

//九宫格棋子  输赢
//规则： 三行 三列 三对角线 三反对角线 如果全是X(1)或者O(0)，那么胜出
public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		//定义表格size
		final int SIZE=3;
		int[][] board = new int[SIZE][SIZE];
		boolean getResult = false;//默认是false
		int numOfX=0;//X和O的个数
		int numOfO=0;
		
		//读入矩阵
		for(int i=0;i<board.length;i++)//表示行
		{
			for(int j=0;j<board[i].length;j++)//表明列，第i行的几列
			{
				board[i][j]=in.nextInt();
				
			}
		}
		//扫描矩阵
		for(int i=0;i<board.length;i++)//表示行
		{
			System.out.println("");
			for(int j=0;j<board[i].length;j++)//表明列，第i行的几列
			{
				System.out.print(board[i][j]+" ");
				
			}
		}
		//检查行
		CH_RAW:
		for(int i=0;i<board.length;i++)//表示行
		{
			for(int j=0;j<board[i].length;j++)
			{
				if(board[i][j]==1)//嵌套在i行的大循环中
				{
					numOfX ++;
				}
				else
				{
					numOfO ++;
				}
				if(numOfX==3||numOfO==3)
				{
					getResult=true;
					break CH_RAW;//非常有必要！！
				}
			}
			
		}
		
		//检查列
		if(!getResult)
		{
			numOfX=0;
			numOfO=0;
			for(int i=0;i<board.length;i++)//表示行
			{
				for(int j=0;j<board[i].length;j++)
				{
					if(board[j][i]==1)//嵌套在j列大循环中
					{
						numOfX ++;
					}
					else
					{
						numOfO ++;
					}
					if(numOfX==3||numOfO==3)
					{
						getResult=true;
						break;
					}
				}
				
			}
		}
		
		//检查对角线
		if(!getResult)
		{
			
			numOfX=0;
			numOfO=0;
			for(int i=0;i<SIZE;i++)
			{
				if(board[i][i]==1)
				{
					numOfO++;
				}
				else
				{
					numOfO++;
				}
			}
			if(numOfX==3||numOfO==3)
			{
				getResult=true;
			}
			
		}

		
//		检查反对角线
		if(!getResult)
		{
			
			numOfX=0;
			numOfO=0;
			for(int i=0;i<SIZE;i++)
			{
				if(board[i][SIZE-i-1]==1)
				{
					numOfX++;
				}
				else
				{
					numOfO++;
				}
			}
			if(numOfX==3||numOfO==3)
			{
				getResult=true;
			}
		}

// 判断谁赢
		System.out.println("");
		if(getResult)
		{
			if(numOfX==SIZE)
			{
				System.out.println("X WIN");
			}
			else
			{
				System.out.println("O WIN");
			}
		}
		else
		{
			System.out.println("无人获胜");
		}
	}
	
}

output:

input:
1
1
1
1
1
0
0
0
0
output:
1 1 1
1 1 0
0 0 0
X WIN

请注意 一定要加 break 外层循环，不然该矩阵判定O获胜。

6-1 字符类型-1

char 数字字母或者汉字都可以

6-1-1字符计算

c=‘A’
如果c++,那么是‘B’
c=‘汉’
如果c++,那么是’汊’(这个是unicode的字符列表中汉的下一个字)

6-1-2 大小写换算

‘A’----65(int)
‘a’----97(int)
a’-‘A’=32
‘A’-‘B’=-1
‘a’-‘b’=-1
‘汉’-‘A’=27656

综上所述：
a>A
B>A
‘汉’>A

6-1 字符类型-2

逃逸字符：用来表达无法印出来的控制字符或特殊字符，由一个反斜杠‘\’开头，后面跟上另一个字符，这两个字符合起来组合成一个字符。

操作	含义
\b	回退一格
\t	到下一个表格位
\n	换行
\r	回车
"	双引号
’	单引号
\\	反斜杠本身

【反斜杠b】–回退一格
abc/bd—abd
abc/b—abc
并不是删除，而是下一个字符取代最后一个位置。

【反斜杠t】–制作表格按列输出
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);

	System.out.println("abc\t123\t356");
	System.out.println("a\t23\t56");
}
}

output(对齐输出)
abc 123 356
a 23 56

【反斜杠n】–换行
【反斜杠r】–回车

6-1 字符类型-3

包裹类型可以用包裹类型定义变量，定义范围。
比如整数类型Interger:4个字节相当于32bit ,可以表示所有的整数,最大值范围：【0 ~ 2^32-1】，用Integer.MAX_VALUE来表示。

基础类型	包裹类型
boolean	Boolean
char	Character
int	Integer
double	Double

包裹类型-Character

表示方法：Character.isDigit(‘a’)—false

运用函数	判断这个字符是不是
isDigit	数字
isLetter	字母
isLetterOrDigit	字母或数字
isLowerCase	小写字母
isUpperCase	大写字母
isWhitespace	一种空格
toLowerCase	转换成小写
toUpperCase	转换成大写

6-2 字符串-1

字符串表示要用双引号

String s;
String 是一个类，包裹类型的第一个字符也是大写的，String的变量是对象的管理者，并非所有者。就像数组变量是管理者而不是所有者一样。
> String s = new String(“a string”);
表示：三步走—>创建了一个String的对象，用“a string”初始化这个对象，创建管理这个对象的变量s
> String s = ‘hello’
表示：编译器帮你创建一个String类的对象交给s来管理

6-2-1字符串连接

可以用加号进行字符串连接，如果加号两边分别是str 和数字，那么也可以进行连接
“hello”+“world”—>“helloworld”
"I am "+18—>“I am 18”
1+2+“age”—>“3age”
“age”+1+2—>“age12”

运算符“+”从左向右进行，所以结果不同。

	String s = new String("age");
	int a = 1;
	int b = 2;
	System.out.println(s+a+b);//age12
	System.out.println(a+b+s);//3age

6-2-2字符串的管理者

(1)比较是否同一个东西，使用==

  String s = in.next();//input:bye
  System.out.println(s);
  System.out.println(s=="bye");

output
bye
false

(2)比较内容是否相同，使用s.equals

  String s = in.next();//input:bye
  System.out.println(s);
  System.out.println(s.equals("bye"));

output
bye
true

-(3)当两个变量管理同一个字符串，才说明这是两个相同的字符串，如果只是两个字符串的内容相同，不同的管理者之间是不同的，并不能称为相等。

运用函数s1	含义
s1.compareTo(s2)	比较两字符串大小，结果大于零表示s1大，小于零表示s2大，等于零表示两者相等
compareToIgnoreCase	不区分大小写地来比较大小
length()	获得String的长度
charAt(index)	访问String里的字符
s.substring(n)	得到从n位置到末尾的全部内容
s.substring(b,e)	得到从b位置到e位置之前的内容

6-2-3遍历String字符串

public class Main {
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	String s1 = "abc";
	for(int i=0;i<s1.length();i++)
		System.out.println(s1.charAt(i));
}
}

output
a
b
c

注意字符串是不可以做for-each循环的

6-2-4 输出子串substring

函数	含义
s.substring(n)	得到从n位置到末尾的全部内容
s.substring(b,e)	得到从b位置到e位置之前的内容

	String s1 = "abcde汉字";
	System.out.println(s1.substring(2));//cde汉字(2,3,4)
	System.out.println(s1.substring(0,2));//ab(0,1)

6-2-5 寻找字符

函数	含义
s.indexOf©	得到c字符所在的位置(index)，-1表示不存在
s.indexOf(c,n)	从n号位置开始寻找c字符
s.indexOf(t)	找到字符串t所在的位置
从右边开始查找	s.lastIndexOf©
	s.lastIndexOf(c,n)
	s.lastIndexOf(t)

使用方法，以及如何找到第二个4的位置：

	String s1 = "0123X456345汉字";
	System.out.println(s1.indexOf("X45"));//字符串要用双引号//4
	System.out.println(s1.indexOf('4'));//5
	//如果需要找到第二个4
	int loc = s1.indexOf('4');//5
	System.out.println(s1.indexOf('4',loc+1));//9

6-2-6 字符串其他操作

函数	含义
s.startWith(t)	检查是否是字符串开头的，可以有空格
s.endsWith(t)	结尾的，可以有空格
s.trim	删除字符串前后的空格
s.replace(c1,c2)	替换，c2字符串取代c1
s.toLowerCase()	全部小写
s.toUpperCase()	全部大写

	String s1 = "  0123X456345abc汉字     ";
	System.out.println(s1.startsWith(s1));
	//true，可以前面是空格
	System.out.println(s1.endsWith(s1));
	//true
	System.out.println(s1.trim());
	//删除空格0123X456345abc汉字
	System.out.println(s1.replace('4','Z'));
	//  0123XZ563Z5abc汉字
	System.out.println(s1.toLowerCase());
	//  0123x456345abc汉字
	System.out.println(s1.toUpperCase());
	//  0123X456345ABC汉字
	System.out.println(s1);
	//字符串本身不会被修改   0123X456345abc汉字

注意
所有的字符串都是不可变得，对他们的操作的结果都是制造出新的字符串出来

6-2-7 swith-cas中使用字符串

switch(s){
case"this":…break;
case"that":…break;
}

6-2-8 Math类

数学	含义
abs绝对值	abs(-12)—>12
pow幂次	pow(2,3)—>8.0
random随机数	random()—>一个0到1之间的随机数
round四舍五入	10.5—>11

7-1函数定义与运用

求和，求出1到10,20到30,35到45的三个和(同时)

//求和，求出1到10,20到30,35到45的三个和
public class Main {
public static void Sum(int a,int b) 
{
	int sum=0;
	for(int i=a;i<=b;i++)
	{
		sum=sum+i;
	}
	System.out.println(a+"到"+b+"的和是"+sum);
}
public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	Sum(1,10);
	Sum(20,30);
	Sum(30,45);

7-1-1 没有范围值的return

使用关键字void，函数中不要用return。

7-1-2 函数参数中的类型匹配

范围由大到小： char–int–double
或者是使用强制转换。

注意 java语言在调用函数时，永远只能传值给函数。

7-1-3 传值，形参，实参

（参数）形参：函数中设置的参数
（值）实参：主函数中实际调用的参数

7-1-4 本地变量

定义在函数内部的变量都是本地变量

7-1-5 块的含义

块就以为着大括号

蘑菇屋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java入门浙江大学版-bilibili（二）

#bilibilijava文章目录4-2循环控制-3-逻辑运算4-3循环计算-1习题1-公式计算f(n)=1+1/2+1/3+1/4+...习题2-公式计算f(n)=1-1/2+1/3-1/4+...习题3-求最大公约数5-1数组习题4-投票统计5-2数组计算数组拷贝方式数组判断相等方式寻找数组中某数x在data数组中的位置（效率不高）for-each 循环--遍历数组5-2数组计算3寻找前50...
复制链接

扫一扫