划重点, 考试要考的

Java 常用方法总结

看到java书上有那么多自带的方法, 感觉如果不总结就容易忘掉.

试试记笔记效果咋样吧.

试试就试试

输入输出

输入

1
2
3
4
5
6
7
8
9
import java.util.Scanner;
Scanner input = new Scanner(System.in);
// 读入整型
input.nextInt();
// 读入浮点型
input.nextFloat();
// 读入双精度浮点型
input.nextDouble();
// 依此类推, 不再列举

输出

  • 输出后换行
    System.out.println("hello world");
  • 输出后不换行
    System.out.print("hello world");
  • 功能更强大, 类似C语言中的 printf()
    System.out.printf("|%5d|",2*6); // => | 12|
    + 格式控制符 结果
    %d 整数
    %8d 整数, 右对齐, 输出宽度为 8
    %-6d 整数, 左对齐, 输出宽度为 6
    %s 字符串同理, 只是把 d 换成 s
    %f 浮点数
    %8f 浮点数, 右对齐, 输出宽度为 8
    %.2f 浮点数, 精确到百分位
    %16.3% 浮点数, 精确到千分位, 输出宽度为 16

基本数据类型

浮点数

  • 控制小数位
    1
    2
    3
    4
    double scale = 3.1015926; 
    //设定保留多少位小数的模板,如保留三位小数就是#0.000
    DecimalFormat fnum = new DecimalFormat("#0.000");
    String d=fnum.format(scale);

字符 (以下省略Character.)

1
2
3
4
5
6
7
boolean isDigit(ch); //是数字?
boolean isLetter(ch); //是字母?
boolean isLetterOrDigit(ch); //是字母或数字?
boolean isLowerCase(ch); //是小写?
boolean isUpperCase(ch); //是大写?
boolean toLowerCase(ch); //转为小写
boolean toUpperCase(ch); //转为大写

字符串(以下省略String.)

基本函数

1
2
3
4
5
6
7
8
9
length()
charAt(index) //返回字符串中第index位的字符, 类似 string[index]
toUpperCase() //全部大写
toLowerCase()
trim() //去除两端空格
indexOf(char parm) //返回字符串中 parm 第一次出现的位置
indexOf(string parm)
substring(int startIndex) //返回index到结束的字串
substring(int startIndex, int endIndex) //返回中间的字符串, 不包括终点.

修改某几位的字符串

1
2
// 变量同上面
sb.replace(2,4,"bc");

字符串比较

1
2
3
4
5
6
7
8
String s = "abc";
System.out.println(s.compareTo("aaa"));
System.out.println(s.compareTo("abc"));
System.out.println(s.compareTo("bbb"));

1
0
-1

StringBuilder/Stringbuffer

这两个类型都是用来处理字符串操作的, 区别主要在于前者线程安全. 所以使用方法大同小异.
StringBuffer sb = new StringBuffer("abc dds");

删除某位字符

1
sb.deleteCharAt(1); //=> "ac dds"

加入字符串

1
sb.insert(1,"bs"); //=> "absbc dds"

数学函数 (以下省略 Math. )

三角函数

1
2
3
4
5
6
sin(double a);
cos(double a);
tan(double a);
acos(double a); //arccos
asin(double a); //arcsin
atan(double a); //arctan

幂运算, 对数运算

1
2
3
4
5
exp(double a); //e 的 a 次方
log(double a); //以 2 为底
log10(double a);
pow(double a, double b); // a 的 b 次方
sqrt(double a);

取整

1
2
3
4
5
6
double ceil(double x);  //向上取整
double floor(double x); //向下取整
//返回最接近参数的整数值, 若存在两个这样的数, 则返回其中的偶数
double rint(double x);
int round(float x); //四舍五入
long round(double x)

其它

1
2
3
4
random() // 随机数  0 <= x < 1.0
abs(a)
max(a,b)
min(a,b)

类和对象

类的声明公式

1
2
[可见度] class ClassName [extends 一个类的名字] [implements 若干个 interface 的名字] {
}

对象默认父类 – Object

  • clone() 拷贝
  • equals(Object obj) 判断对象是否相等
  • finalize() 相当于析构函数
  • getClass() 获取类的相关信息
  • hashCode() 获取对象的哈希值
  • toString() 类转为字符串

a istanceof B

返回一个boolean : a(实例) 是否是 B(class) 的实例.
如果 B 是 A 的父类, a istanceof B 仍然为 true.
但如果 A 是 B 的父类, 该表达式为假.

@override

在子类的函数名前使用@override, 编译器会自动检查父类中有没有同名的方法供子类override. 若没有, 则直接报错.

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!

构造函数

  1. 类似C++的构造函数(不再赘述)
  2. this()构造函数, 只能在构造函数中调用其它构造函数时使用.(且必须写在第一行)
    与通常的构造函数不同, this()不会产生新的对象, 而是对自身属性进行修改.
  3. super(): 与this()类似, 显式调用父类的构造函数.
    不然会默认调用父类的无参构造函数.inal
  4. 只要类中显示定义了一个构造函数, 则不会产生默认无参构造函数.

静态

  • static{} 代码块仅在类被加载时执行一次
  • static 静态方法会失去多态特性.

final

  • final 类
  • final 方法
  • final 变量

接口的声明

1
interface A [extends ...其它接口名...]{}

异常

语法

  • 关键字

    1
    2
    3
    4
    5
    6
    7
    8
    9
    try{
    throw e
    /* 亦可能在方法中抛出 */
    }catch(Exception e){
    /* 异常处理 */
    }
    final{/*无论是否有异常都会执行*/

    }
  • 一个函数若可能抛出异常:

    1
    2
    3
    void function() throws exceptions{
    throw new Exception()
    };

    则调用该方法的地方都要try, catch.
    除了RuntimeException

  • 异常实例的方法 e.getMessage() 可以获得异常信息.

Arrays 比较器

java.util.Arrays中的sort函数可以对数组自动排序, 默认排序顺序为由小到大. 例如

1
2
int[] arr = new int[100];
Arrays.sort(arr);

但是如果要使用其它的排序策略或者要排序无法直接比较大小的对象需要自定义一个类, 这个类需要继承Comparator<>接口, 并在其中构造compare函数.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Student类的定义(简略)
public class Student{
String name;
double score;
}
// cmp函数及其所在的类的定义
import java.util.Comparator;
public class cmp implements Comparator<Student>{
public int compare(Student a,Student b) {
// 排序顺序和这里返回的int值有关
// 如果 > 分支里返回 >0 的值, < 分支里返回 <0 的值
// 那么按照升序排列
// 如果 < 分支里返回 >0 的值, > 分支里返回 <0 的值
// 那么按照降序排列
if(Math.abs(a.score - b.score) < 0.00001)
return 0;
else if(a.score > b.score)
return 1;
else
return -1;
}
}
// 调用sort
Student[] arr = new Student[5];
Arrays.sort(arr, new cmp());

多线程

线程的创建和使用

定义一个Thread类的子类. 覆盖Thread的run()方法. 然后创建该子类的实例.

线程的启动需要使用start(), 而不是run()

1
2
3
4
5
6
7
8
9
10
public class MyThread extends Thread{
public void run(){
System.out.println(Thread.currentThread().getName());
}
}
static public void main(String args[]){
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t2.start(); t1.start();
}

线程调度

让其它线程有机会执行, 可以使用以下方法

  • Thread.sleep()
    线程睡眠
  • Thread.yield()
    线程让步, 在线程的run()中调用.
  • Thread.join()
    1
    2
    3
    4
    5
    6
    Machine machine = new Machine();
    machine.start();
    Sytem.out.print...
    machine.join();
    // 主线程会等待machine线程运行结束再向下运行.
    Sytem.out.print...

I/O

文件读写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.io.File;
import java.io.FileReader;
import java.io.Reader;

public String readFromTxt(String filename) throws Exception{
Stringbuff buf = new StringBuffer();
char[] chars = new char[1024];
Reader reader = new FileReader(filename);
int readed = reader.read(chars);
while(readed != -1){
buf.append(chars, 0, reader);
readed = reader.read(chars);
}
reader.close();
return buf.toString();
}

作业代码

Home01

  • Home01.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    package com.huawei.classroom.student.h01;
    public class Home01 {

    public Home01() {
    // TODO Auto-generated constructor stub
    }
    // 判断a,b,c是否能够构成三角形的三个边
    public boolean isTriangle(int a,int b,int c) {
    if(a+b <= c) {
    return false;
    }else if(b+c <= a){
    return false;
    }else if(a+c <= b){
    return false;
    }else {
    return true;
    }
    }

    // 判断两个浮点数是否相等,一般认为如果两个浮点数的差值小于0.0001,即认为相等
    public boolean isEq(float f1, float f2) {
    if(Math.abs(f1-f2) < 0.0001) {
    return true;
    }
    else {
    return false;
    }
    }
    // 将学生百分之成绩变换为A(>=90,B>=80且非A,C>=70且非C,D>=60且非D,E 其他)
    public String getGrade(int score) {
    if(score >= 90) {
    return "A";
    }else if(score >= 80) {
    return "B";
    }else if(score >= 70) {
    return "C";
    }else if(score >= 60) {
    return "D";
    }else if(score < 60){
    return "E";
    }else {
    return null;
    }
    }
    // 判断一个数字是否是质数,如果是质数返回true,否则false
    public boolean isPrime(int i) {
    if(i==2){
    return true;
    }else{
    int finish = (int)(Math.sqrt(i)) + 1;
    for(int a = 2;a <= finish;a++) {
    if(i % a == 0) {
    return false;
    }
    }
    return true;
    }
    }

    // 计算 整数 i+(i+1)....+j的加和
    public int getSum(int i, int j) {
    int sum = 0;
    for(;i <= j;i++) {
    sum += i;
    }
    return sum;
    }

    // 返回大于等于i,且小于等于j的所有的偶数的加和
    public int getEvenSum(int i,int j) {
    int sum = 0;
    if(i % 2 != 0) {
    i++;
    }
    for(;i <= j;i+=2) {
    sum += i;
    }
    return sum;
    }

    // 返回i,j,k中的最大值
    public int getMax(int i,int j,int k) {
    int result = (i < j)? j:i;
    result = (result<k)? k:result;

    return result;
    }
    // 判断一个数是否是水仙花数,
    // 所谓 "水仙花数 "是指一个三位数,其各位数字立方和等于该数本身。例如:153是一个 "水仙花数 ",因为153=1的三次方+5的三次方+3的三次方。
    public boolean isNarcissisticNum(int i) {
    if(i < 100 || i > 999) {
    return false;
    }else {
    int a,b,c,d = i;
    a = d % 10;
    d /= 10;
    b = d % 10;
    d /= 10;
    c = d;
    if( Math.pow(a,3)+ Math.pow(b, 3)+Math.pow(c, 3) == i ) {
    return true;
    }
    }
    return false;
    }
    // 判断一个数是否是完全数,
    // 一个数如果恰好等于它的因子之和,这个数就称为 "完全数 "。
    public boolean Perfectnumber(int i) {
    int sum = 0;
    for(int a = 2;a < i;a++) {
    if(i % a == 0) {
    sum += a;
    }
    }
    if(sum + 1 == i) {
    return true;
    }else {
    return false;
    }
    }
    }

Home02

  • Home02.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    package com.huawei.classroom.student.h02;
    public class Home02 {
    public Home02() {
    // TODO Auto-generated constructor stub
    }
    // 一个整数,判断整数是不是回文数。例如:12321是回文数,个位与万位相同,十位与千位相同
    public boolean isSymmetricalNum(int i) {
    int[] a = new int[12];
    int index = -1;
    while(i > 0) {
    a[++index] = i % 10;
    i /= 10;
    }
    for(int front=0,back=index;front<back;front++,back--) {
    if(a[front]!=a[back]) {
    return false;
    }
    }
    return true;
    }
    // 计算i的阶乘
    public long factorial(int i) {
    if(i == 0) {
    return 1;
    }else {
    return i*factorial(i-1);
    }
    }

    // 计算裴波那契数列的第n项
    public long calcPeponacci(int i) {
    if(i == 1) {
    return 1;
    }else if(i == 2) {
    return 1;
    }else {
    return calcPeponacci(i-1)+calcPeponacci(i-2);
    }
    }
    // 将一个正整数各位颠倒后返回
    public int reverseInt(int i) {
    int result = 0;
    while(i > 0) {
    result = result*10 + i%10;
    i /= 10;
    }
    return result;
    }
    // 计算一个整数各位数之和
    public int mySum(int i) {
    int sum = 0;
    while(i > 0) {
    sum += i%10;
    i /= 10;
    }
    return sum;
    }

    // 计算两个整数的最小公倍数
    public int LCM(int i,int j) {
    // 首先保存下两个数的因数
    int[] a = new int[30];
    int[] b = new int[30];
    int indexOfA = -1,indexOfB = -1;
    int tmp = 2;
    while(i > 1) {
    if(i%tmp == 0) {
    a[++indexOfA] = tmp;
    i /= tmp;
    }else {
    ++tmp;
    }
    }
    tmp = 2;
    while(j > 1) {
    if(j%tmp == 0) {
    b[++indexOfB] = tmp;
    j /= tmp;
    }else {
    ++tmp;

    }
    }
    // 现在两个数的因子都被保存在了a 和 b 两个数组中
    // 再用他们组合出最小公倍数
    int left = 0,right = 0;
    int result = 1;
    for(;left <= indexOfA && right <= indexOfB;) {
    if(a[left] == b[right]) {
    result *= a[left];
    left++;right++;
    }else if(a[left] < b[right]) {
    result *= a[left++];
    }else {
    result *= b[right++];
    }
    }
    for(;left <= indexOfA;left++) {
    result *= a[left];
    }
    for(;right <= indexOfB ;right++) {
    result *= b[right];
    }
    return result;
    }
    // 计算两点之间的距离
    public double getDistance(double x1,double y1,double x2,double y2){
    return Math.sqrt(Math.pow(x1-x2,2) + Math.pow(y1-y2, 2));
    }

    // 返回一个数组中最大元素的位置(元素不会出现相等的情形)
    public int findMaxIndex(int[] a ) {
    int index = 0;int tmpMax = -999999;
    for(int i=0;i < a.length;i++) {
    if(tmpMax < a[i]) {
    index = i;
    tmpMax = a[i];
    }
    }
    return index;
    }

    // 判断一个字符串中一个字符出现的次数
    public int getCharCount(String str ,char c) {
    int length = str.length();
    int count = 0;
    for(int i = 0;i < length;i++) {
    if(str.charAt(i)==c) {
    count++;
    }
    }
    return count;
    }
    // 判断一个字符串中一个字符串出现的次数
    public int getStrCount(String str ,String sub) {
    int len1 = str.length();
    int len2 = sub.length();
    int count = 0;
    for(int i=0;i < len1-len2;i++) {
    if(str.substring(i,i+len2).equals(sub)) {
    count ++;
    }
    }
    return count;
    }
    }

Home03

  • Home03.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    package com.huawei.classroom.student.h03;

    public class Home03 {

    public Home03() {
    // TODO Auto-generated constructor stub
    }

    // 返回一个正整数数组a中偶数的个数
    public int getEvenCount(int[] a) {

    int count = 0;
    for(int i = 0; i<a.length; i++) {
    if(a[i]%2==0)count++;
    }

    return count;
    }
    /**
    * 将个10进制非负整数变成8进制的数
    * 例如输入 binToOct(8) 返回 "10"
    * 输入 binToOct(10) 返回 "12"
    * 难度系数1星
    * @return
    */
    public String binToOct(int i) {
    // 完成本函数里面的代码

    String oct = "";
    while(i!=0) {
    oct = (char)(i%8 + '0')+oct;
    i /= 8;
    }
    System.out.println();
    return oct==""?"0":oct;
    }


    /**
    * 比较两个字符串,返回其中最小的字符串,提示按String.compareTo 比较即可
    * 例如 getMin("abc","abe")返回"abc"
    * 难度系数1星
    * @return
    */
    public String getMinStr(String s1,String s2) {
    // 完成本函数里面的代码

    return (s1.compareTo(s2) < 0) ? s1 : s2 ;
    }

    /**
    * 判断一个字符串中是否包含大写字母,包含返回true,否则false
    * 例如:containsUpperCase("Abc")返回true
    * 难度系数1星
    * @return
    */
    public boolean containsUpperCase(String str) {
    // 完成本函数里面的代码

    for(int i = 0; i < str.length(); i++) {
    if(Character.isUpperCase(str.charAt(i)))
    return true;
    }
    return false;
    }

    /**
    * 转换一个字符串中的大小写,原来是大写字母的地方转换为小写,小写字母地方转为大写
    * 例如:switchUpperLower("Abc")返回 "aBC"
    * 难度系数1星
    * @return
    */
    public String switchUpperLower(String str) {
    // 完成本函数里面的代码
    char[] ch = str.toCharArray();
    String s0 = "";
    for(int i = 0; i < str.length(); i++) {
    if(Character.isUpperCase(ch[i])) s0 += Character.toLowerCase(ch[i]);
    else if(Character.isLowerCase(ch[i])) s0 += Character.toUpperCase(ch[i]);
    else s0 += ch[i];
    }
    return s0;
    }

    /**
    * 去掉一个字符串中所有的空格
    * 难度系数1星
    * 例如:zipSpace(" a b c ")返回 "abc"
    * @return
    */
    public String zipSpace(String str) {
    // 完成本函数里面的代码
    str = str.replace(" ","");
    return str;

    }

    /**
    * 将一个正整数转换为10位字符串,不足位数左补0;
    * 例如:exandIntToStr10(123) 返回 "00000000123"
    * 难度系数1星
    * @param i
    * @return
    */
    public String exandIntToStr10(int i) {

    String str = Integer.toString(i);
    int len = 10-str.length();
    for(int j = 0; j < len; j++) {
    str = '0'+ str;
    }
    return str;
    }

    /**
    * 将一个正整数转换为len位字符串,不足位数左补0;
    * 如果这个正整数本身位数超过len,则直接将这个正整数返回即可
    * 例如:exandIntToStrL(123,4) 返回 "0123"
    * exandIntToStrL(123,2) 返回 "123"
    * 难度系数2星
    * @param i
    * @param len
    * @return
    */
    public String exandIntToStrL(int i,int len) {
    String str = Integer.toString(i);
    if(str.length() > len)return str;

    int len0 = len - str.length();
    for(int j = 0; j < len0; j++) {
    str = '0'+str;
    }

    return str;
    }


    /**
    * 设二元一次方程 a*x*x+bx+c=0;
    * 的系数分别为a,b,c
    * 请将这个方程的两个实数根放在数组中返回,如果没有实数解则返回null
    * 例如 getRoot(1,-2,1)返回 {1,1}
    * 例如 getRoot(1,-2,2)返回 null
    * 难度系数1星
    * @return
    */
    public double[] getRoot(double a,double b,double c) {
    double[] ans = new double[2];

    double delta = b*b -4*a*c;

    if(delta < -0.00001) {
    return null;
    }else if(Math.abs(delta) < 0.00001 ) {
    ans[0] = (-b)/(2*a);
    ans[1] = (-b)/(2*a);
    return ans;
    }else {
    ans[0] = (-b + Math.sqrt(delta))/(2*a);
    ans[1] = (-b - Math.sqrt(delta))/(2*a);
    return ans;
    }
    }

    /**
    * 返回杨辉三角( Pascal triangle,请百度 杨辉三角 或者 Pascal triangle )第i行的系数,杨辉三角第一行定义为1
    * 提示:从顶部的单个1开始,下面一行中的每个数字都是上面两个数字的和
    * 例如getPascalTriangle(1)返回{1},
    * getPascalTriangle(2)返回{1,2,1}
    * 测试的时候,系数肯定不会超过int的范围
    * 难度系数3星
    * @param line
    * @return
    */
    public double getFac(int i,int j) {
    double result = 1;
    while(i > j) {
    result *= i--;
    }
    return result;
    }

    public int[] getPascalTriangle(int i) {
    int[] arr = new int[i];
    // arr[j] = C(j,i-1)
    // = (i-1)!/((j!)*((i-1-j)!))
    // = (A(i-1-j,i-1)/(A(j,j)
    for(int j = 0;j < i/2+1; j++) {
    arr[j] = (int)(Math.round((getFac(i-1,i-1-j))/((getFac(j,1)))));
    }
    for(int m = 0,n = i-1;n > m;n--,m++) {
    arr[n] = arr[m];
    }
    return arr;
    }

Home04

  • A.java

    1
    2
    3
    package com.huawei.classroom.student.h04;
    public class A{
    }
  • B.java

    1
    2
    3
    package com.huawei.classroom.student.h04;
    interface B{
    }
  • C.java

    1
    2
    3
    package com.huawei.classroom.student.h04;
    interface C extends B{
    }
  • D.java

    1
    2
    3
    package com.huawei.classroom.student.h04;
    public class D extends A implements C{
    }
  • E.java

    1
    2
    3
    package com.huawei.classroom.student.h04;
    public class E implements C{
    }
  • Child.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    package com.huawei.classroom.student.h04;
    public class Child extends Parent {
    Child(){
    }
    Child(String a){
    super.name = a;
    }
    @Override
    public String speak() {
    return "child";
    }
    }
  • Parent.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    package com.huawei.classroom.student.h04;
    public class Parent {
    String name;

    Parent(){
    //TODO
    }
    Parent(String a){
    name = a;
    }
    public String speak() {
    return "parent";
    }
    public String getName() {
    return name;
    }
    }
  • MyStack.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    package com.huawei.classroom.student.h04;

    public class MyStack {
    int size; // the length of stack
    int number = 0; // the number of int
    int[] list = null;

    MyStack(){
    size = 0;
    number = 0;
    }
    MyStack(int size){
    this.size = size;
    number = 0;
    list = new int[size];
    }
    public boolean isEmpty() {
    return number == 0;
    }
    public boolean isFull() {
    return size == number;
    }
    public void push(int n) {
    if(this.isFull()) return;
    else {
    list[number++] = n;
    }
    }
    public int pop() {
    if(this.isEmpty()) return 0;
    else {
    return list[--number];
    }
    }
    }

Home05

q01

1
2
3
4
5
6
7
8
9
10
11
package com.huawei.classroom.student.h05.q01;
public class Dog {
int times = 0;
public void feed()throws Exception {
System.out.println(times);
if(times == 3) {
throw new Exception("I can not eat more!");
}
times ++;
}
}

q02

  • LoginUtil.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package com.huawei.classroom.student.h05.q02;
    public class LoginUtil {
    public void login(String a, String b) throws InvalidUserExcetpion{
    if (a.equals("a") && b.equals("a")) {

    }else {
    throw new InvalidUserExcetpion();
    }
    }
    }

q03

1
2
3
4
5
6
package com.huawei.classroom.student.h05.q02;
public class InvalidUserExcetpion extends Exception{
InvalidUserExcetpion(){
super();
}
}

q03

  • Bank.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    package com.huawei.classroom.student.h05.q03;
    public class Bank {
    int money = 0;
    public Bank() {
    // TODO Auto-generated constructor stub
    }
    /**
    * 初始账户余额为0,每次存款账户余额增加
    * @param money
    */
    public void save(int money) {
    this.money += money;
    }
    /**
    *
    * 当账号余额<money的时候,抛出NoMoneyException(NoMoneyException需要你自己定义)
    * 否则账号余额减少
    * @param money
    * @throws NoMoneyException
    */
    public void get(int money) throws NoMoneyException {
    if(money > this.money) {
    throw new NoMoneyException();
    }
    else {
    this.money -= money;
    }
    }
    }
  • NoMoneyException.java

    1
    2
    3
    4
    5
    6
    package com.huawei.classroom.student.h05.q03;
    public class NoMoneyException extends Exception{
    NoMoneyException(){
    super();
    }
    }

q04

  • AgeCheck.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package com.huawei.classroom.student.h05.q04;
    public class AgeCheck implements AgeCheckInterface{
    public void checkAge(int age) {
    if (age < 0 || age > 200) {
    throw new RuntimeException();
    }
    }
    AgeCheck(){
    }
    }
  • AgeCheckInterface.java

    1
    2
    3
    4
    5
    6
    package com.huawei.classroom.student.h05.q04;
    public interface AgeCheckInterface {

    public void checkAge(int age);

    }

q05

  • TypeValidator.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    package com.huawei.classroom.student.h05.q05;
    /**
    * 这个类里面可以增加适当的属性,方法,但是不可以修改现有的方法的声明
    * @author yjn
    *
    */
    public class TypeValidator {
    public TypeValidator() {
    // TODO Auto-generated constructor stub

    }
    public void validate(Object obj){
    if(!(obj instanceof String)) {
    throw new RuntimeException();
    }
    }
    }

Home06

  • Home06.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    package com.huawei.classroom.student.h06;
    import java.util.HashMap;
    import java.util.HashSet;
    /**
    * 把你作业的代码写到这个类里面
    * 不可以修改类的名字、包名、和固有的几个方法名以及方法的可见性
    * 可以增加其他方法、属性、类
    * 可以引用jdk的类
    * 不要引用jdk1.8以外第三方的包
    *
    * @author yjn
    *
    */
    public class Home06 {
    public Home06() {
    // TODO Auto-generated constructor stub
    }
    /**
    * 计算出一段文字中不重复的字符的个数,例如“天津市天津大学 ”不重复字符为5
    * 提示:使用java.util.HashSet
    * 难度系数1星
    * @param s
    * @return
    */
    public int getDistinctCharCount(String s) {
    HashSet set = new HashSet();
    for(int i = 0;i < s.length();i++) {
    set.add(s.charAt(i));
    }
    return set.size();
    }
    /**
    * 返回一段文字中,出现频率最高的字符(不考虑并列第一的情况) 例如:getFrequentChar("好好学习") 返回'好'
    * 例如:getFrequentChar("我是天津大学软件学院学生") 返回'学'
    * 提示:使用一个长度为65535的数组,或者使用HashMap
    * 难度系数2星
    * @param s
    * @return
    */
    public char getFrequentChar(String s) {
    char ans = ' ';
    int max = 0;
    HashMap map = new HashMap();
    for(int i = 0;i < s.length();i++) {
    char index = s.charAt(i);
    if(map.containsKey(s.charAt(i))) {
    map.put(index,(int)map.get(index)+1);
    }else {
    map.put(index,1);
    }
    max = max>(int)map.get(index)?max:(int)map.get(index);
    ans = max>(int)map.get(index)?ans:index;
    }
    return ans;
    }
    /**
    * 返回一段文字中,出现频率最高的词(每个词由2个字符构成,任意两个相邻的字符称为一个词,例如“天津大学,你好”由“天津”“津大”“大学”“学,”“,你”“你好” 6个词构成)
    * 不会出现频率最高并列的情况
    * 提示:使用HashMap
    * 难度系数2星
    * @param content
    * @return
    */
    public String getFrequentWord(String content){
    HashMap map = new HashMap();
    int max = 0;
    String ans = " ";
    for(int i = 0;i < content.length()-1;i++) {
    String key = content.substring(i,i+2);
    if(map.containsKey(key)) {
    map.put(key,(int)map.get(key)+1);
    }else {
    map.put(key, 1);
    }
    ans = max>(int)map.get(key)?ans:key;
    max = Math.max(max, (int)map.get(key));
    }
    return ans;
    }
    /**
    * 把一个StringBufer中所有的空格去掉
    * 提示:不能新建StringBuffer对象,必须在原来的基础上删掉原来字符串
    * 难度系数1星
    * @param buf
    */
    public void zipStringBufer(StringBuffer buf) {
    for(int i = 0;i < buf.length();i++) {
    if(buf.charAt(i) == ' ') {
    buf.deleteCharAt(i--);
    }
    }
    }
    }

Home07

  • Analysis.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118

    package com.huawei.classroom.student.h07;

    import java.io.Closeable;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.Reader;

    /**
    * 在本包下增加合适的类和方法,使得Test类能够测试通过 具体要求见实验一 注意 本程序不但要测试通过,还需要写适当的注释
    *
    * 不要引用jdk1.8以外第三方的包
    *
    * @author cjy
    *
    */
    public class Analysis {

    /**
    *
    */
    public Analysis() {
    // TODO Auto-generated constructor stub
    }

    /**
    * 提示 :将一个文本文件读取到一个字符串中返回 提示:参考ch09.ReadWriteFileCharDemo.java
    *
    * @param filename
    * 红楼梦文本文件的全路径名
    * @return 文本的内容
    */
    private String readFromTxt(String filename) throws Exception {
    Reader reader = null;
    try {
    StringBuffer buf = new StringBuffer();
    char[] chars = new char[1024];
    reader = new FileReader(filename);
    int readed = reader.read(chars);
    while (readed != -1) {
    buf.append(chars, 0, readed);
    readed = reader.read(chars);
    }
    return buf.toString();
    } finally {
    close(reader);
    }
    }

    /**
    * 关闭输入输入流
    *
    * @param inout
    */
    private void close(Closeable inout) {
    if (inout != null) {
    try {
    inout.close();
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    }
    }
    /**
    * 将红楼梦文本文件拆分为120个章节
    *
    * @param content
    * @return 返回120个元素的字符串数组
    */
    private String[] splitContentToChapter(String content) {
    // 提示 使用 content.split(" 第[一,二,三,四,五,六,七,八,九,十,零]{1,5}回 ");正则表达拆分
    // 百度一下正则表达式
    String[] contents = content.split(" 第[一,二,三,四,五,六,七,八,九,十,零]{1,5}回 ");
    String result[] = new String[contents.length-1];
    for(int i = 0;i < result.length;i++) {
    result[i] = contents[i+1];
    }
    return result;
    }
    /**
    * 统计某个字符 在一个字符串里面出现的频度
    *
    * @param content
    * @param sub
    * @return
    */
    private int getCount(String content, String sub) {
    int count = content.split(sub).length-1;
    return count;
    }
    /**
    * 计算红楼梦中某个字符串 str 出现的频率
    *
    * @param filename
    * 存放了红楼梦这本书的文本文件名
    * @param str
    * 要统计的字符串
    * @return 一个长度是120的一维数组
    */
    public int[] getStringFrequent(String filename, String str) {
    // 提示 1 readFromTxt 得到小说的内容
    String text = null;
    try {
    text = readFromTxt(filename);
    }catch(Exception e){
    System.out.println("error");
    }
    // 提示 2 splitContentToChapter 得到每章内容
    String[] subText = splitContentToChapter(text);
    // 提示 3 针对每章 调用 getCount方法
    int[] counts = new int[subText.length];
    for(int i = 0;i < counts.length;i++) {
    counts[i] = getCount(subText[i],str);
    }
    return counts;
    }
    }

Home08

  • DataUtil.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    package com.huawei.classroom.student.h08;
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.Reader;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.HashSet;
    import java.util.Iterator;
    public class DataUtil {
    public DataUtil() {
    // TODO Auto-generated constructor stub
    }
    /**
    * 提示 本方法能够从一个文本文件中读取每一行,将每一行放到一个List<String>返回
    * @param detailFileName
    * @return
    * @throws IOException
    */
    private List<String> readFromFile(String detailFileName) throws IOException {
    Reader reader;
    BufferedReader bReader = null;
    try {
    reader = new FileReader(detailFileName);
    bReader = new BufferedReader(reader);
    List<String> list = new ArrayList<String>();

    String line = bReader.readLine();
    while (null != line) {
    list.add(line);
    line = bReader.readLine();
    }
    return list;
    } finally {
    if (bReader != null) {
    bReader.close();
    }
    }

    }
    /**
    * detailFileName文件是一个超市的购物小票 每行表示一次购物,每个商品之间用半角逗号分开 请找出 “哪 两个商品总被同时 购买"
    * 将这两个商品名字用逗号分隔 返回
    *
    * @param detailFileName
    * 购物小票的文件名
    * @return 哪 两个商品总被同时 购买,两个商品之间用半角逗号分隔
    */
    public String getFrequentItem(String detailFileName) throws Exception {
    List<String> list = readFromFile(detailFileName);
    HashSet<String> space = new HashSet<String>();
    for(int i = 0;i < list.size();i++) {
    String[] tmp = list.get(i).split(",");
    for(int j = 0;j < tmp.length;j++) {
    space.add(tmp[j]);
    }
    }
    int tmp=0,size=space.size(),count=0;
    String[] store = new String[size];
    for(Iterator<String> it=space.iterator();it.hasNext();) {
    store[tmp++] = it.next();
    }
    String name1,name2,ans=null;
    tmp = 0;
    for(int i = 0;i < size;i++) {
    for(int j = 0;j < size;j++) {
    if(j==i) {
    break;
    }else {
    name1 = store[i];name2 = store[j];
    tmp = 0;
    for(int k = 0;k < list.size();k++) {
    String item = list.get(k);
    if(item.indexOf(name1)!=-1&&item.indexOf(name2)!=-1) {
    tmp++;
    }
    }
    ans=tmp>count?name1+","+name2:ans;
    count=tmp>count?tmp:count;
    }
    }
    }
    return ans;
    }
    }

Home09

  • MyTool.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    package com.huawei.classroom.student.h09;
    import java.util.Set;
    import java.util.HashSet;
    import java.io.File;
    import java.io.FileReader;
    import java.io.Reader;
    /**
    * 在本包下增加合适的类和方法, 本程序不但要测试通过,还需要写适当的注释
    *
    * 不要引用jdk1.8以外第三方的包
    *
    * @author yjn
    *
    */
    public class MyTools {
    String picDir;
    String contentOfTxt;
    /**
    *
    * @param studentListFile 存放学生名单的文件名
    * @param picDir 图片存放的目录(不会包含子目录)
    */
    public MyTools(String studentListFile,String picDir) {
    this.picDir = picDir;
    try {
    this.contentOfTxt = readFromTxt(studentListFile);
    }catch(Exception e) {
    e.printStackTrace();
    }
    }
    private String readFromTxt(String filename) throws Exception{
    Reader reader = null;
    StringBuffer buf = new StringBuffer();
    char[] chars = new char[1024];
    reader = new FileReader(filename);
    int readed = reader.read(chars);
    while (readed != -1) {
    buf.append(chars, 0, readed);
    readed = reader.read(chars);
    }
    reader.close();
    return buf.toString();
    }
    public Set<String> getOverSizeStudentList() throws Exception {
    File dir = new File(picDir);
    File[] fileList = dir.listFiles();
    Set<String> set = new HashSet<String>();
    for(int i = 0;i < fileList.length;i++) {
    if(fileList[i].length() > 128 * 1024) {
    String name = fileList[i].getName();
    int index = name.indexOf('.');
    set.add(name.substring(0,index));
    }
    }
    return set;
    }
    public Set<String> getNoPicStudentList() throws Exception {
    //String students = readFromTxt(this.studentListFileName);
    File dir = new File(picDir);
    File[] fileList = dir.listFiles();
    Set<String> set = new HashSet<String>();
    String[] items = this.contentOfTxt.split("\n");
    for(int i = 0;i < items.length;i++) {
    String number = (items[i]).split("\t")[0];
    boolean flag = true;
    for(int j = 0;j < fileList.length;j++) {
    String name = fileList[j].getName();
    int index = name.indexOf('.');
    if(name.substring(0,index).equals(number)) {
    flag = false;
    }
    }
    if(flag) {
    set.add(number);
    }
    }
    return set;
    }
    }

Home10

q1

  • Dog.java
    1
    2
    3
    4
    5
    6
    7
    8
    package com.huawei.classroom.student.h10.q01;
    public class Dog {
    Dog(){
    }
    public String speak() {
    return "wangwang";
    }
    }

q2

  • Person.java

    1
    2
    3
    4
    package com.huawei.classroom.student.h10.q02;
    public interface Person {
    public String getName();
    }
  • Student.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package com.huawei.classroom.student.h10.q02;
    public class Student implements Person {
    String name;
    Student(String name){
    this.name = name;
    }
    Student(){
    this("youjianing");
    }
    public String getName() {
    return this.name;
    }
    }

q3

  • ArrayUtil.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package com.huawei.classroom.student.h10.q03;
    public class ArrayUtil {
    public ArrayUtil() {
    // TODO Auto-generated constructor stub
    }
    public int getMin(int[] array) {
    int tmp = 2147483647;
    for(int i = 0;i < array.length;i++) {
    tmp = array[i]<tmp?array[i]:tmp;
    }
    return tmp;
    }
    }

q4

  • StrUtil.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    package com.huawei.classroom.student.h10.q04;
    public class StrUtil {
    StrUtil(){
    }
    public String removeDulpicatedChar(String s) {
    String ans = "";
    for(int i = 0;i < s.length();i++) {
    char tmp = s.charAt(i);
    boolean flag = true;
    for(int j = 0;j < ans.length();j++) {
    if(ans.charAt(j) == tmp) {
    flag = false;
    break;
    }
    }
    if(flag) {
    ans += tmp;
    }
    }
    return ans;
    }
    }

q5

  • StudentUtilB.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    package com.huawei.classroom.student.h10.q05;
    import java.util.Arrays;
    import java.util.HashMap;
    public class StudentUtilB {
    StudentUtilB(){
    }
    public String[]sort(String content){
    String[] students = content.split(";");
    String[] ans = new String[students.length];
    HashMap<Integer,String> map = new HashMap<Integer,String>();
    int[] score = new int[students.length];
    for(int i = 0;i < students.length;i++) {
    String item = students[i];
    String[] data = item.split(",");
    score[i] = (int)Integer.valueOf(data[1]);
    map.put(score[i], data[0]);
    }
    Arrays.sort(score);
    for(int i = 0;i < students.length;i++) {
    ans[students.length-1-i] = (String)map.get(score[i]);
    }
    return ans;
    }
    }

Home11

  • CharCount.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    package com.huawei.classroom.student.h11;
    public class CharCount {
    char c;
    int count;
    CharCount(char c,int count){
    this.c = c;
    this.count = count;
    }
    }
  • cmp.java

    1
    2
    3
    4
    5
    6
    7
    8
    package com.huawei.classroom.student.h11;
    import java.util.Comparator;
    public class cmp implements Comparator<CharCount>{
    cmp(){}
    public int compare(CharCount a,CharCount b) {
    return (a.count < b.count)?1:(a.count > b.count)?-1:0;
    }
    }
  • cmpByScoreDesc.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    package com.huawei.classroom.student.h11;
    import java.util.Comparator;
    public class cmpByScoreDesc implements Comparator<Student> {
    String Desc;
    cmpByScoreDesc(String Desc){
    this.Desc = Desc;
    }
    public int compare(Student a,Student b) {
    System.out.println(""+a.score.get(this.Desc)+b.score.get(this.Desc));
    Double x = a.score.get(this.Desc) == null?(0.0):a.score.get(this.Desc);
    Double y = b.score.get(this.Desc) == null?(0.0):b.score.get(this.Desc);
    if(Math.abs(x-y) < 0.00001 )
    return 0;
    else if(x>y)
    return -1;
    else return 1;
    }
    }
  • cmpByTotalScore.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package com.huawei.classroom.student.h11;
    import java.util.Comparator;
    public class cmpByTotalScore implements Comparator<Student> {
    public int compare(Student a,Student b) {
    if(Math.abs(a.total - b.total) < 0.00001) {
    return 0;
    }else if(a.total > b.total) {
    return -1;
    }else {
    return 1;
    }
    }
    }
  • Home11Char.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    package com.huawei.classroom.student.h11;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Arrays;

    public class Home11Char {
    public Home11Char() {
    }
    /**
    * 将一个字符串中字符按出现频率的高到低排序返回,如果两个字符出现的频率一样,则将最先出现的字符排在前面
    * 例如:orderChar(“abcdefg”)返回 “abcdefg”
    * orderChar(“abcdefgg”)返回 “gabcdef”
    * orderChar(“abcdefgge”)返回 “egabcdf”
    * orderChar(“天津大学软件学院”)返回 “学天津大软件院”
    * @param content
    * @return
    */
    public String orderChar(String content) {
    HashSet set = new HashSet();
    int i = 0;
    for(i = 0;i < content.length();i++) {
    set.add(content.charAt(i));
    }
    Iterator it = set.iterator();
    CharCount[]arr = new CharCount[set.size()];
    System.out.println(set.size());
    i = 0;
    while(it.hasNext()) {
    int count = 0;
    char c = (char)it.next();
    for(int j = 0;j < content.length();j++){
    if(content.charAt(j) == c) {
    count++;
    }
    }
    arr[i++] = new CharCount(c,count);
    }
    Arrays.sort(arr,new cmp());
    String ans = "";
    for(i = 0;i < arr.length;i++) {
    ans += arr[i].c;
    }
    return ans;
    }
    }
  • Home11Score.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    package com.huawei.classroom.student.h11;
    import java.util.HashMap;
    import java.util.Set;
    import java.util.Iterator;
    import java.util.Arrays;
    import java.util.ArrayList;
    public class Home11Score {
    HashMap<String,Student> nameToStu;
    public Home11Score() {
    nameToStu = new HashMap<String,Student>();
    }
    /**
    * 设置每个同学的成绩一个字符串中包含了若干学生选修课的成绩
    * (每个同学选修的课程数量不同,成绩可能出现小数),
    * 构成方式如下:学生姓名,科目,成绩;
    * 学生姓名,科目,成绩....;
    * @param content
    */
    public void setScores(String content) {
    String[] items = content.split(";");
    for(int i = 0;i < items.length;i++) {
    String[] info = items[i].split(",");
    if(!nameToStu.containsKey(info[0])) {
    nameToStu.put(info[0], new Student(items[i]));
    }else {
    nameToStu.get(info[0]).add(items[i]);
    }
    }
    Set<String> set = this.nameToStu.keySet();
    Iterator<String> it = set.iterator();
    while(it.hasNext()) {
    this.nameToStu.get(it.next()).calTotal();
    }
    }
    /**
    * 返回学生名单,按指定的课程成绩由高到低排序(不会出现并列情况)
    * @param courseName
    * @return
    */
    public String[] getStudentdNameByScoreDesc(String courseName){
    Set<String> set = this.nameToStu.keySet();
    Iterator<String> it = set.iterator();
    int cnt = 0;
    // 先判断有多少人会被排名(只是为了知道开多大的数组)
    while(it.hasNext()) {
    if(nameToStu.get(it.next()).score.get(courseName) != null) {
    cnt ++;
    }
    }
    Student[] stus = new Student[cnt];
    it=set.iterator();
    int index = 0;
    // 把这些人加进待排序的数组
    while(it.hasNext()) {
    Student person = this.nameToStu.get(it.next());
    if(person.score.get(courseName) != null) {
    stus[index++] = person;
    }
    }
    // 排序
    Arrays.sort((Student[])(stus),new cmpByScoreDesc(courseName));
    String[] ans = new String[cnt];
    // 提取出名字
    for(int i = 0;i < cnt;i++) {
    ans[i] = stus[i].name;
    }
    return ans;
    }
    /**
    * 返回学生名单,按指定的课程总成绩由高到低排序(不会出现并列情况)
    * @return
    */
    public String[] getStudentdNameByTotalScoreDesc(){
    Set<String> set = this.nameToStu.keySet();
    Iterator<String> it = set.iterator();
    Student[] stus = new Student[this.nameToStu.size()];
    int index = 0;
    while(it.hasNext()) {
    stus[index++] = this.nameToStu.get(it.next());
    }
    Arrays.sort(stus,new cmpByTotalScore());
    String[] ans = new String[stus.length];
    for(int i = 0;i < ans.length;i++) {
    ans[i] = stus[i].name;
    }
    return ans;
    }
    }
  • Student.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    package com.huawei.classroom.student.h11;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Set;
    public class Student {
    String name;
    HashMap<String, Double> score;
    Double total;
    Student(String info){
    total = 0.0;
    score = new HashMap<String, Double>();
    add(info);
    }
    public void add(String info) {
    String[] infos = info.split(",");
    this.name = infos[0];
    score.put(infos[1], Double.parseDouble(infos[2]));
    }
    public void calTotal() {
    Set<String> set = score.keySet();
    Iterator<String> it = set.iterator();
    int cnt = 0;
    while(it.hasNext()) {
    cnt += 1;
    this.total += this.score.get(it.next());
    }
    }
    }

Home12

  • MyThread.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    package com.huawei.classroom.student.h12;
    import java.util.ArrayList;
    public class MyThread extends Thread{
    int num;
    ArrayList<Long>[] result;
    long base;
    long top;
    public boolean isPrime(long a) {
    if(a == 2) return false;
    else {
    long mark = (long)Math.sqrt(a)+1;
    for(long i = 2;i <= mark;i++) {
    if(a % i == 0) return false;
    }
    }
    return true;
    }
    public void setVar(ArrayList<Long>[]res, int num, long base, long top) {
    this.num = num;
    this.result = res;
    this.base = base;
    this.top = top;
    }
    public void run() {
    this.result[num] = new ArrayList<Long>();
    for(Long i = base;i < top;i++) {
    if(isPrime(i)) {
    this.result[num].add(i);
    }
    }
    }
    }
  • PrimeUtil.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    package com.huawei.classroom.student.h12;
    import java.lang.reflect.Array;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Iterator;
    public class PrimeUtil {
    /**
    * 使用threadCount个线程计算出 [start,end] 之间所有的质数,并按递增顺序放到list中
    * 其中 end-start >threadCount
    * @param start
    * @param end
    * @param threadCount 线程数量
    * @return
    */
    public long[] multiThreadGetPrimeList(long start,long end,int threadCount){
    Long simpleThreadRange = (end - start)/threadCount + 1;
    ArrayList<Long>[] results = new ArrayList[threadCount] ;
    int i = 0;
    MyThread[] threads = new MyThread[threadCount];
    for(i = 0;i < threadCount-1 ;i++) {
    threads[i] = new MyThread();
    threads[i].setVar(results, i, start+i*simpleThreadRange, start+(i+1)*simpleThreadRange);
    threads[i].start();
    }
    threads[i] = new MyThread();
    threads[i].setVar(results, i, start+i*simpleThreadRange, end);
    threads[i].start();
    try {
    for(i = 0;i < threadCount;i++) {
    threads[i].join();
    }
    }catch(Exception e) {
    System.out.println("Error");
    }
    ArrayList<Long> ans = new ArrayList<Long>();
    for(i = 0;i < threadCount;i++) {
    ans.addAll(results[i]);
    }
    Iterator<Long> it = ans.iterator();
    long[] a = new long[ans.size()];
    i = 0;
    while(it.hasNext()) {
    a[i++] = (long)it.next();
    }
    Arrays.sort(a);
    return a;
    }
    }