第二周作业

1. 编写一个圆类 Circle 的 Java 程序。圆类有2个数据成员 , 分别是半径radius和颜色 color, 这些属性可查.看 get 也可以重新设置 set, 另外 , 圆还可以返回其面积 area 。 ```java package Weekly_Task;

/**

• @author Devil

• @create 2021-10-25-15:11 */ public class Circle{ private double radius; private String color;

  public Circle(double radius, String color){

   this.radius = radius;
   this.color = color;

  }

  public double getRadius() {

   return radius;

  }

  public String getColor() {

   return color;

  }

  public void setRadius(double radius) {

   this.radius = radius;

  }

  public void setColor(String color) {

   this.color = color;

  }

  public double getArea(){

   return Math.PI*radius*radius;

  } } ```

1. (1)ArrayList底层采用_结构来实现的，LinkedList底层采用_数据结构来实现的

在一般情况下，上述两种数据结构的优缺点是什么？

答：数组 链表 数组缺点：不适合动态地改变它存储的数据，如增加、删除等(时间效率低)；优点：查询、修改方面的时间效率高。 链表缺点：查询、修改它储存的数据时间效率低；优点：适合动态地改变它存储的数据，如增加、删除等(时间效率高)。

(2)HashSet底层数据结构在JDK8做了一次重大升级，JDK8之前采用的是**____**来实现的，也就是数组 +链表来实现；到了JDK8之后采用**____**来实现。

答： HashMap 数组+链表+红黑树

1. 编写一个程序，能够统计一句话中各个字母出现的次数。

示例 1：

复制代码
输入：I love Echo 输出：{c=1, e=1, E=1, v=1, h=1, I=1, l=1, o=2}

提示：

map.containsKey(i)//使用Map做该题时，该方法可判断map集合中是否含有该key String s=str.replace(" ", ""); //该代码可去除字符串中的空格

代码：

package Weekly_Task;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
/**
 * @author Devil
 * @create 2021-10-25-15:43
*/
public class Demo5 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        HashMap<Character, Integer> map = new HashMap<>();
        String str = input.nextLine();
        String s = str.replace(" ", "");
        for (int i = 0; i < s.length(); i++) {
            if (!map.containsKey(s.charAt(i))) {
                map.put(s.charAt(i), 1);
            } else {
                map.put(s.charAt(i), map.get(s.charAt(i)) + 1);
            }
        }
        Iterator<Map.Entry<Character, Integer>> iter = map.entrySet().iterator();
        System.out.print("{");
        while (iter.hasNext()) {
            Map.Entry<Character, Integer> key = iter.next();
            System.out.print(key.getKey() + "=" + key.getValue());
            if (!iter.hasNext()) {
                System.out.println("}");
            }else{
                System.out.print(", ");
            }
        }
    }
}

控制台输出：

I love Echo
{c=1, e=1, E=1, v=1, h=1, I=1, l=1, o=2}

1. 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11，15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

方法一：暴力法
代码：

package Weekly_Task;
import java.util.ArrayList;
import java.util.Scanner;
/**
 * @author Devil
 * @create 2021-10-25-16:04
 */
public class Demo6 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        Scanner input = new Scanner(System.in);
        int number = input.nextInt();
        while(number>0){
            arrayList.add(input.nextInt());
            number--;
        }
        int target = input.nextInt();
        for (int i = 0; i < arrayList.size() - 1; i++) {
            for (int j = i + 1; j < arrayList.size(); j++) {
                if (arrayList.get(i) + arrayList.get(j) == target) {
                    System.out.println("[" + i + "," + j + "]");
                    break;
                }
            }
        }
    }
}

方法二：HashMap两次迭代
代码：

package Weekly_Task;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
/**
 * @author Devil
 * @create 2021-10-25-16:04
 */
public class Demo6 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        Scanner input = new Scanner(System.in);
        int number = input.nextInt();
        while(number>0){
            arrayList.add(input.nextInt());
            number--;
        }
        int target = input.nextInt();
        HashMap<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < arrayList.size(); i++) {
            map.put(arrayList.get(i),i);
        }
        for (int i = 0; i < arrayList.size(); i++) {
            if(map.containsKey(target-arrayList.get(i))&&map.get(target-arrayList.get(i))!=i){
                System.out.println("["+i+","+map.get(target-arrayList.get(i))+"]");
                break;
            }
        }
    }
}

方法三：hashmap一次迭代
代码：

package Weekly_Task;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
/**
 * @author Devil
 * @create 2021-10-25-16:04
 */
public class Demo6 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        Scanner input = new Scanner(System.in);
        int number = input.nextInt();
        while(number>0){
            arrayList.add(input.nextInt());
            number--;
        }
        int target = input.nextInt();
        HashMap<Integer,Integer> map = new HashMap<>();
        //在一个没有num[i]的map中查找满足target-num[i]的值的键，再将num[i]添加到map中
        for (int i = 0; i < arrayList.size(); i++) {
            int complement = target - arrayList.get(i);
            if(map.containsKey(complement)){
                System.out.println("["+map.get(complement)+","+i+"]");
            }
            map.put(arrayList.get(i),i);
        }
    }
}

控制台输出：

输入：4
2 7 11 15 9
输出：[0,1]

1. 创建一个对象类，成员变量为name和age，请存储学生对象并遍历

要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
提示：创建TreeSet集合，使用比较器排序。
示例

对象属性:
"xishi",23
"diaochan",28
"wangzhaojun",28
"yangyuhuan",25
排序后输出结果:
23,xishi
25,yangyuhuan
28,diaochan
28,wangzhaojun

代码：

package Weekly_Task;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Scanner;
import java.util.TreeSet;
/**
 * @author Devil
 * @create 2021-10-25-16:22
 */
public class Demo7 {
    public static void main(String[] args) {
        TreeSet<Objects> set = new TreeSet<>();
        Scanner input = new Scanner(System.in);
        Objects o1 = new Objects(input.next(), input.nextInt());
        Objects o2 = new Objects(input.next(), input.nextInt());
        Objects o3 = new Objects(input.next(), input.nextInt());
        Objects o4 = new Objects(input.next(), input.nextInt());
        set.add(o1);
        set.add(o2);
        set.add(o3);
        set.add(o4);
        System.out.println("排序后输出结果：");
        Iterator<Objects> iter = set.iterator();
        while (iter.hasNext()) {
            Objects o = iter.next();
            System.out.println(o.getName() + "," + o.getAge());
        }
    }
}
class Objects implements Comparable {
    private String name;
    private int age;
    public Objects(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public int compareTo(Object object) {
        Objects o = (Objects) object;
        if(this.age==o.age){
            return 1;
        }
        else{
            return this.age-o.age;
        }
    }
}

控制台输出:

对象属性：
"xishi" 23
"diaochan" 28
"wangzhaojun" 28
"yangyuhuan" 25
排序后输出结果：
"xishi",23
"yangyuhuan",25
"diaochan",28
"wangzhaojun",28