《中国大学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.0000001

2.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<number){
        System.out.println("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<cnt; i++)//遍历数组
  {
    if(numbers[i]>average)
    {
      System.out.println(numbers[i]);
    }
  }
}

2.数组
是一种容器（放东西的东西），其所有元素都有相同的数据类型。
元素个数可以是变量。

3.length
这是具有可扩展性的代码。
每个数组有一个内部成员 length，会告诉你它的元素的数量。

for(i=0;i<grade.length;++i){
  sum+=grade[i];
}

4.数组变量

直接初始化数组
（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]); //16

5.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;i<x;i++)
{
  if(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;i<x;i+=2)//odd
  {
    if(x%i == 0)
    {
      isPrime = false;
      break;
    }
  }
}

方法三：无须到x-1，到sqrt(x)就可以了。

for(int i=3;i<Math.sqrt(x);i+=2)
{
  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<primes.length;x++)//一个个查，直到凑满50个素数的数组
{   //x代表待排查的数
  for(int i=0;i<cnt;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.length;i++)//把所有位置都标记为是素数
{
  isPrime[i]=true;
}
for(int i=2; i<isPrime.length;i++)
{
  if(isPrime[i])//如果是素数
  {
    for(int k=2;i*k<isPrime.length;i++)//素数的倍数一定不是素数
    {
      isPrime[i*k]=false;//标记为非素数
    }
  }
}
for(int i=2;i<isPrime.length;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)
{
  ...
}

《中国大学Mooc》零基础学Java语言-翁恺 学习知识点总结

第一周

第二周

第三周

第四周

第五周

第六周

字符类型

字符串

第七周

猜你喜欢

《中国大学Mooc》零基础学Java语言-翁恺学习知识点总结