《中国大学Mooc》零基础学Java语言-翁恺 学习知识点总结
来源 《中国大学Mooc》零基础学Java语言-翁恺
仅作为知识点总结
第一周
1.关于算法
——计算机计算的步骤就是算法。
- 1.1 枚举法求u和v的最大公约数
(1) 设t为2；
(2) 如果u和v都能被t整除，则记下这个t。
(3) t加1后重复第二步，直到t等于u或v。
(4) 那么，记下的最大的t即为u和v的最大公约数gcd。
比如一个例子：
int a = in.nextInt();
int b = in.nextInt();
int ret = 0;
int i;
for( i=2; i<=a && i<=b; i=i+1){
if(a%i==0){
if(b%i==0){
ret=i;
}
}
}
System.out.println(ret);- 1.2 辗转相除法求u和v的最大公约数
(1) 如果v等于0，计算结束，u就是最大公约数。
(2) 如果v不等于0，那么计算u除以v的余数，让u等于v，而v等于那个余数。
(3) 回到第一步。
int u = 32;
int v = 26;
while( v!=0 ){
int temp = u%v;
u = v;
v = temp;
}2.关于程序的执行
解释：借助一个程序，那个程序能试图理解你的程序，然后按照你的要求执行。
编译：借助一个程序，就像一个翻译，把你的程序翻译成计算机真正能懂的语言——机器语言——写的程序，然后，这个计算语言写的程序就能直接执行了。
3.关于读输入
import java.util.Scanner;
...
Scanner in = new Scanner(System in);
//输入Scan之后，按下键盘Alt+“／”键，Eclipse下自动补全。
System.out.println(in.nextLine());
//让in这个对象做读入下一行的动作，结果交给System.out这个对象去打印一行。4.关于常量与变量
- 读整数
int price;
price = in.nextInt();//- 常量
final int AMOUNT = 100;
//final相当于c++里的const
//final是一个修饰符，表示这个变量的值一旦初始化，就不能再修改了。5.关于强制性类型转换问题
- 当浮点数和整数放到一起运算时，Java会将整数转换为浮点数。
- 强制性转换的优先级高于四则运算。
double a = 1.0;
double b = 2.0;
int i = (int)a/b;
//会报错
int i = (int)(a/b);
//不会报错第二周
1.判断两个浮点数是否相等的方法
Math.abs(f1-f2)<0.00000012.Eclipse中的debug
(1) 双击某一行设置断点。
(2) 运行左边一只虫子。
(3) 布局为java布局，需要变yes。
(4) resume(F8)继续运行。
(5) step over(F6)下一步。
3.多路分支
switch (type)
{
case 1:
case 2:
...
break;
default:
System.out.println(...);
break;
}第三周
1.while循环
当条件满足时，不断地重复循环体内的语句。
2.验证
测试程序常使用边界数据，如有效范围两端的数据、特殊的倍数等。
- 个位数
- 10
- 0
- 负数
3.do-while循环
会首先先执行完一步后再检查判断条件是否符合。
4.猜数游戏
...
int number = (int)(Math.random()*100+1);
// 每次召唤Math.random()就会得到一个[0,1)范围内的随机数。
int count = 0;
int a = 0;
System.out.println("我已经想好了一个随机数：");
do{
System.out.println("Guss:");
a = in.nextInt();
count++;
if(a>number){
System.out.println("Too big.");
}
else if(a"Too small.");
}
}while(a!=number)
System.out.println("Congratulations! You get it for " + number + "times!")
... 第四周
1.int类型范围
[-2^31,2^31-1]
2.break vs continue
- break跳出当前循环
- continue跳过循环这一轮剩下的语句进入下一轮
3.逻辑类型
关系运算的结果是一个逻辑值，true或false。这个值可以保存在一个对应的逻辑类型的变量中，这样的变量类型是boolen。
boolean flag = true;
boolean tooHigh,tooSmall,tooRough;
boolean done=false;4.goto
for(;;){
for(;;){
if(...)goto OUT;
}
}
OUT:...5.格式设置
System.out.println("%2.f",sum);
//保留两位，四舍五入6.逆序数出一个整数
Scanner in = new Scanner(System.in);
int x = in.nextInt();
int y = 0;
do
{
y=y*10+x%10;
x/=10;
}while(x>0)
System.out.println(y);第五周
1.计算一系列数平均值，并输出大于平均数的所有数
int x;
double sum = 0;
int cnt = 0;//索引值
int[] numbers =new int[100];//定义数组
x = in.nextInt();
while( x!= -1)
{
numbers[cnt] = x;//对数组中的元素赋值
sum += x;
cnt++;
x = in.nextInt();
}
if(cnt>0){
double average = sum/cnt;
for(int i=0; i//遍历数组
{
if(numbers[i]>average)
{
System.out.println(numbers[i]);
}
}
} 2.数组
是一种容器（放东西的东西），其所有元素都有相同的数据类型。
元素个数可以是变量。
3.length
这是具有可扩展性的代码。
每个数组有一个内部成员 length，会告诉你它的元素的数量。
for(i=0;i4.数组变量
直接初始化数组
（1）new创建的数组会得到默认的0值；
（2）int[] scores = {87,77,22,11}; //编译器会替你数数。数组变量赋值
（1）普通变量为所有者；
（2）对于数组变量，ta只是管理者。
int[] a=new int[10]; //创建数组，变量名为a
a[0] = 5;
int[] b = a; //创建数组b，b指向a指向的存储单元
b[0] = 16; //改变b[0]，即改变a[0]
System.out.println(a[0]); //165.for each
//格式
for(<类型><变量>:<数组>){
...
//适合遍历数组
}
//实例
int[] data={2,3,5,7,9,11,34,12};
int x=in.nextInt();
boolean found = false;
for(int k: data)//对于data数组中的每一个元素，逐个拿出来对比
{
if(x==k)
{
found=true;
break;
}
}
if(found)
{
System.out.println(x+"在其中");
}
else
{
System.out.println(x+"不在其中");
}6.素数
- 判断是否为素数
方法一：从2到x-1测试是否可以整除。
int x = in.nextInt();
boolean isPrime = true;
if(x==1)
{
isPrime=false;
}
for(int i=2;iif(x%i==0)
{
isPrime = false;
break;
}
}
if(isPrime)
{
System.out.println(x+"素数");
}
else
{
System.out.println(x+"不是素数");
} 方法二：去掉偶数后，从3到x-1，每次加2。
if(x==1 || x%2 == 0 && x!=2)
{
isPrime = false;
}
else
{
for(int i=3;i2)//odd
{
if(x%i == 0)
{
isPrime = false;
break;
}
}
} 方法三：无须到x-1，到sqrt(x)就可以了。
for(int i=3;i2)
{
if(x%i==0)
{
isPrime = false;
break;
}
} - 构造素数表
方法一：
int[] primes = new int[50];//存放发现的素数的数组
primes[0]=2;//第一个素数为2
int cnt =1;//数组的下标
MAIN_LOOP: //先查看下面是否为素数，如果不是
for(int x=3;cnt//一个个查，直到凑满50个素数的数组
{ //x代表待排查的数
for(int i=0;i//这里分母找的是已经是素数的素数
{
if(x%primes[i]==0)//判断是否为素数，如果不是，直接跳出到 MAIN_LOOP 下的for循环
{
continue MAIN_LOOP;
}
}
primes[cnt++]=x;// 如果是，把它放到数组里
}
for(int k:primes)//遍历
{
System.out.print(k+" ");
}
System.out.println(); 方法二：
- 令x为2
- 将2x、3x、4x直至ax小于n的数标记为非负数
- 令x为下一个没有被标记为非素数的数，重复2；直到所有的数都已经尝试完毕
boolean[] isPrime = new boolean[100];//**找100以内的素数**
for(int i=2;i//把所有位置都标记为是素数
{
isPrime[i]=true;
}
for(int i=2; iif(isPrime[i])//如果是素数
{
for(int k=2;i*k//素数的倍数一定不是素数
{
isPrime[i*k]=false;//标记为非素数
}
}
}
for(int i=2;i//遍历打印素数
{
if(isPrime[i])
{
System.out.print(i+" ");
}
}
System.out.println(); 7.二维数组
int[][] b = new int[3][5];
//
int[][] a = {
{1,2,3,4},
{1,2,3},//如果省略，表示0
}//可以有逗号，古老的传统第六周
字符类型
1.字符
+ Java使用Unicode来表示字符，可以表达包括汉字以内的多种文字。
‘\u0041’表示的是十六进制，对应的是unicode编码中的 ‘A’。
汉字比西文字母的编码值大些。
- char也可以和int之间相互赋值
a + ‘a’ - ‘A’ 可以把一个大写字母变成小写字母
a + ‘A’ - ‘a’ 可以把一个小写字母变成大写字母
2.逃逸字符
\b: 回退一格，如在有些操作系统
System.out.println("abc\bd");
//abd\n: 换行
\r: 回车（与换行不一样的！）
3.包裹类型
- 每种基础类型都有对应的包裹类型
| 基础类型 | 包裹类型 |
|---|---|
| boolean | Boolean |
| char | Character |
| int | Integer |
| double | Double |
- 包裹类型的变量
Integer i=10;
Integer i=new Integer(10);
Integer i=new Integer("10");- 包裹类型的作用
获得该类型的最大值最小值
Integer.MIN_VALUE;//214948364
Integer.MAX_VALUE;//其中'.'为运算符字符串
1.注意点
(1) String是一个类，String的变量是对象的管理者而非所有者；
(2) new=创建：String s=new String(“a string”);
(3) in.next() : 读入一个单词，单词的标志是空格(空格、tab和换行)；
(4) in.nextLine : 读入一整行；
(5) 所有的字符串都是不可变的，对它们的操作的结果都是创造出来的心得字符串。
2.一些操作
| 操作 | 说明 |
|---|---|
| a.equals(“bye”) | 比较内容是否相同，与==还是有区别的，==有时代表管理者也要相同 |
| s1.compareTo(s2) | 若s1比s2小，则为负；相等为0；大为1 |
| s1.compareToIgnoreCase(s2) | 不区分大小写比较 |
| s.length() | 字符串长度 |
| s.charAt(index) | index范围为0到length()-1，返回在index上的单个字符 |
| s.substring(n) | 得到从n号位置到末尾的全部内容 |
| s.substring(b,e) | 得到从b号位置到e号位置的全部内容 |
| s.indexOf(c,n) | 左边从n号位置开始找(-1表示没找到)，注意为索引值 |
| s.lastIndexOf(c,n) | 右边开始找，同上 |
| s.startsWith(t) | 判断是不是以t开头 |
| s.endsWith(t) | 判断是不是以t结尾 |
| s.trim() | 删除两端空格 |
| s.replace(c1,c2) | c1换成c2 |
| s.toLowerCase | 转换为小写字母 |
| s.toUpperCase | 转换为大写字母 |
第七周
1.对象的操作
String s="hello";
int i = s.length();//这个就是调用了函数
System.out.println(s+"bye");2.注意要点
- 保持单一出口
- 当函数期望的参数类型比调用函数时给的值的参数类型宽的时候，编译器能悄悄替你把类型转换好
- 基本模版类似
public static void sum(int a, int b)
{
...
}