目录
1、
将下列数据：“hello”、123、6.9、“hello”、“”、“Hello”、StringBuffer s=new StringBuffer(“abc”);中的s，添加到一个ArrayList对象中，并输出结果。
• 练习修改元素、获取元素、打印输出。
• 查找元素“hello”。
• 删除指定的元素“hello”。
• 将元素123替换为1000。
import java.util.*;
public class SixDemo {
public static void main(String[] args) {
ArrayList list1 = new ArrayList();
StringBuffer s = new StringBuffer("abc");
list1.add("hello");
list1.add(123);
list1.add(6.9);
list1.add("");
list1.add("Hello");
list1.add(s);
System.out.println("打印原始的list---");
System.out.println(list1);
System.out.println("修改下标为2的元素、获取下标为2的元素---");
list1.set(2, 456);
System.out.println("下标为2的元素:" + list1.get(2));
System.out.println("修改后的list:" + list1);
System.out.println("查找元素hello的索引:" + list1.indexOf("hello"));
System.out.println("删除hello元素:" + list1.remove("hello"));
Collections.replaceAll(list1, 123, 1000);
//这里需要注意，将list1中的所有123替换成1000
System.out.println("删除元素hello以及将123替换为1000---");
System.out.println(list1);
}
}运行截图：
2、
使用ArrayList集合，对其添加10个不同的元素，并使用Iterator遍历该集合。提示：
• 使用add()方法将元素添加到ArrayList集合中。
• 调用集合的iterator()方法获得Iterator对象，并调用Iterator的hasNext()和next()方法，迭代出集合中的所有元素。
• 查找键盘输入的元素。
• 将重复的元素删除。
import java.util.*;
public class SixDemo {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(56);
list.add(4);
list.add(7);
list.add(8);
list.add(9);
Iterator it = list.iterator();
//foreach 循环 也叫增强for循环
// for (Integer ig : list) {
// System.out.println(ig);
// }
//迭代器Iterator遍历
while (it.hasNext()) {
Object obj = it.next();
System.out.println(obj);
}
//查找键盘输入的元素
System.out.println("请输入要查找的元素：");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
if (list.indexOf(i) != -1) System.out.println("该元素在list集合中的位置为：" + list.indexOf(i));
else System.out.println("该元素不存在！");
//删除重复元素
System.out.println("删除list集合中重复的元素；");
for (int j = 0; j < list.size(); j ++ )
for (int t = j + 1; t > j && t < list.size(); t ++ )
if (list.get(j).equals(list.get(t))) list.remove(t);
System.out.println(list);
}
}运行截图：
3、
去除集合中自定义对象（如Person类，属性包括姓名和年龄）的重复值(对象的成员变量值都相同)。
思路：
先将这些Person类的实例对象存入ArrayList集合中，其中包含重复值（即：该实例的所有变量的值都相同，此时才称为重复），再通过遍历list集合将所有的元素存入HashSet集合中，此时就完成了去重的任务。
需要注意的是，当在HashSet集合中存入字符串时，String类已经重写过equals（）和hashcode（）方法，只需存入元素即可去重。但是对于Person类实例这样的自定义对象，需要在Person类中重写equals（）和hashcode（）方法。
import java.util.*;
public class s6_3 {
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三", 12));
list.add(new Person("李四", 12));
list.add(new Person("王五", 16));
list.add(new Person("李四", 12));
HashSet<Person> hs = new HashSet<>();
Iterator it = list.iterator();
while (it.hasNext()) hs.add((Person) it.next());
System.out.println("删除重复对象：");
System.out.println(hs);
}
}
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person p = (Person) o;
return this.name.equals(p.name) && this.age == p.age;
}
public String toString() {
return "{" + name + "," + age + "}";
}
}运行截图：
4、
编写一个程序获取10个1至指定数值（n）之间的随机整数，要求如下：
• （1）要求随机数不能重复。n值由键盘输入。
import java.util.*;
public class SixDemo {
public static void main(String[] args) {
//1.获取10个[1,n]的数字
//实例化一个可以产生随机数字的对象
Random r = new Random();
//输入n
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
//定义一个存数字的容器
ArrayList<Integer> list = new ArrayList<>();
//若list集合中不包含这个随机产生的[1,n]的数字，则存入
for (int i = 0; i < 10; i ++ ) {
int m = r.nextInt(n) + 1;//这一步必须单独列出来，不能将函数直接带进去，不然会多次产生随机数字
while (!(list.contains(m))) list.add(m);
}
for (Integer li : list) {
System.out.println(li);
}
}
}运行截图：
由图可知：当范围为1~1000时，几乎没有重复元素，此时会有10个不重复的随机数。
当范围为1~5时，会有几个重复元素，此时不重复的随机数只有5个。
• （2）在HashSet集合中添加三个Person对象，把姓名相同的人当做同一个人，禁止重复添加。
提示：Person类中定义name和age属性，重写hashCode()方法和equals()方法，针对Person类的name属性进行比较，如果name相同，hashCode()方法的返回值相同，equals方法返回true。
import java.util.*;
public class SixDemo {
public static void main(String[] args) {
HashSet<Person> hs = new HashSet<>();
hs.add(new Person("张三", 12));
hs.add(new Person("李四", 12));
hs.add(new Person("张三", 14));
System.out.println(hs);
}
}
public class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
return name.hashCode();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person p = (Person) o;
return this.name.equals(p.name);
}
public String toString() {
return "{" + name + "," + age + "}";
}
}
运行截图：
5、
编写程序将一组学生对象的姓名和成绩存入到一个树集（TreeSet）中，完成以下要求：
• （1）使得按照成绩自动降序排列，并输出排序的结果。
import java.util.*;
public class SixDemo {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<>(new Comparator<>() {//要想在compare中直接生成Student参数，需要在这里加上Student的泛型
@Override
public int compare(Object o1, Object o2) {
Student stu1 = (Student) o1;
Student stu2 = (Student) o2;
//注意这里有的Student对象的score相等，如果相等，则按照添加的先后顺序排列
//if (stu2.getScore() >= stu1.getScore()) return 1;
//else return -1;
int i = stu2.getScore() - stu1.getScore();
return i == 0 ? stu1.getName().compareTo(stu2.getName()) : i;//逆序
}
});
ts.add(new Student("张三", 67));
ts.add(new Student("李四", 98));
ts.add(new Student("王五", 87));
ts.add(new Student("赵六", 67));
System.out.println(ts);
}
}
public class Student {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public Student() {
}
public void setName(String name) {
this.name = name;
}
public void setScore(int score) {
this.score = score;
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
}
• （2）从一个无序数组中，剔除重复元素，并按升序排序。
import java.util.*;
public class SixDemo2 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(3);
list.add(23);
list.add(12);
list.add(99);
list.add(23);
System.out.println("原始无序数组" + list);
HashSet<Integer> hs = new HashSet<>();
Iterator it2 = list.iterator();
while (it2.hasNext()) {
Integer i2 = (Integer) it2.next();
hs.add(i2);
}
System.out.println("去重但仍乱序" + hs);
//升序
//这里不需要使用Comparator,因为基本类型的包装类已经实现了第一个方法的Comparable接口
TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
Iterator it = hs.iterator();
while (it.hasNext()) {
Integer i = (Integer) it.next();
ts.add(i);
}
System.out.println("升序排列：" + ts);
}
}
6、
编写一个程序，读取个数不定的整数，然后查找其中出现频率最高的数字。当输入为0时，表示结束输入。如：
如果输入的数据是2 3 40 3 54 -3 3 3 2 0，那么数字3的出现频率是最高的。请一次输入一个数字。
如果出现频率最高的数字不是一个而是多个，则应该将它们全部输出。例如：在线性表9 30 3 9 3 2 4中，3和9都出现了两次，3和9都应该输出。
提示：可以定义两个集合，一个存放所有输入的数据，另一个存放出现频率最高的数字。
import java.util.*;
public class SixDemo {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
//用list1集合存储输入的所有数字
System.out.println("请输入任意数量的数字（0作为停止标志）：");
for (int i = 0; ; i ++ ) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
if (n != 0) list1.add(n);
else break;
}
//求list1中最大的数字，便于给count数组赋值
int max = 0;
for (int i = 1; i < list1.size(); i ++ ) {
if (list1.get(i) >= list1.get(i - 1)) max = list1.get(i);
else max = list1.get(i - 1);
}
//将出现频率最高的数字存放进list2
List<Integer> list2 = new LinkedList<>();
int[] count = new int[max + 1];
for (Integer i : list1) {
count[i] = 0;
for (Integer j : list1) {
if (i == j) count[i] ++ ;
}
//如果没有元素，则直接加入该元素，如果有元素，则判断大小
//若新元素大，则旧元素全删；若相等，则直接加入新元素；否则，下一轮
if (list2.size() >= 1) {
if (count[i] > count[list2.get(0)]) {
//list2.removeAll(list2);
//下面这个不对，list2.size（）的值会一直发生改变
// for (int n = 0; n < list2.size(); n ++ ) list2.remove(n);
int size = list2.size();
for (int n = 0; n < size; n ++ ) list2.remove(0);//这里一直删除第一个元素，而不是第n个，因为第n个数字的位置会改变
list2.add(i);
}
else if (count[i] == count[list2.get(list2.size() - 1)]) {
list2.add(i);
}
else continue;
}
else list2.add(i);
System.out.println("list2现状：" + list2);
}
System.out.println("去重前：" + list2);
//list2集合去重
HashSet<Integer> hs = new HashSet<>();
for (Integer i : list2) {
hs.add(i);
}
//输出频率最高的数字
System.out.println("去重后频率最高的数字为：" + hs);
}
}
7、
选择合适的Map集合保存5个用户的用户名和密码，然后将这些键值对打印出来。
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
public class SixDemo {
public static void main(String[] args) {
Map<String, String> map = new TreeMap<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return 1;//按添加的顺序排列
}
});
map.put("张三","202021");
map.put("李四","23426");
map.put("王五","23045");
map.put("赵六", "sjhgo");
map.put("sgfhfow", "shgiowh");
System.out.println("五对用户名和密码为：" + map);
}
}
8、
统计字符串中每个单词出现的次数，使用HashMap来实现。例如：“Today, We have a class of java, as we kown, java is an object oriented programming language, and java is fun! wish you enjoy it!”，统计结果存储成以下形式：
a-->1
an-->1
and-->1
as-->1……
is-->2
提示：使用String.split(("[ \n\t\r.,;:!?()]")方法进行分词，空格，标点符号等。
思路：
String.split()方法可以将一个长句子分成若干个单词（即可以用字符串数组存储）
import java.util.*;
public class SixDemo {
public static void main(String[] args) {
Map<String, Integer> hm = new HashMap<>();
String strs = "Today, We have a class of java, as we kown, java is an object oriented programming language, and java is fun! wish you enjoy it!";
String[] str = strs.split("[ \n\t\r.,;:!?()]");
for (int i = 0; i < str.length; i ++ )
if (!hm.containsKey(str[i])) hm.put(str[i], 1);
else
{
Integer n = hm.get(str[i]);
hm.put(str[i], n + 1);
}
System.out.println("统计结果如下：");
Iterator<String> it = hm.keySet().iterator();
while (it.hasNext()) {
String keyName = it.next();
System.out.println(keyName + "->" + hm.get(keyName));
}
}
}运行截图：
932
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
