一:分析以下需求，并用代码实现
1.定义List集合，存入多个字符串
2.删除集合中字符串"def"
3.然后利用迭代器遍历集合元素并输出
import java.util.ArrayList;
import java.util.List; public class Topic1
{
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("dsfsd");
arrayList.add("def");
arrayList.add("ghdh");
arrayList.add("fdgd");
arrayList.add("qewr");
for (int i = 0; i < arrayList.size(); i++) {
if (arrayList.get(i)=="def"){
arrayList.remove("def");
}
}
System.out.println(arrayList);
}
}
二:分析以下需求，并用代码实现
1.生成10个1至100之间的随机整数(不能重复)，存入一个List集合
2.然后利用迭代器和增强for循环分别遍历集合元素并输出
3.如：15 18 20 40 46 60 65 70 75 91
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Random; public class Topic2 {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<>();
HashSet<Integer> set = new HashSet<>();
Random ra = new Random();
while(set.size()<=10){
int num = ra.nextInt(100)+1;
set.add(num);
}
arrayList.addAll(set);
System.out.println(arrayList);
}
}
三:分析以下需求，并用代码实现
1.定义List集合，存入多个字符串
2.删除集合元素字符串中包含0-9数字的字符串(只要字符串中包含0-9中的任意一个数字就需要删除此整个字符串)
3.然后利用迭代器遍历集合元素并输出
import java.util.ArrayList;
import java.util.Iterator; public class Topic3 {
public static void main(String[] args) {
//1.定义List集合，存入多个字符串
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("dfsd5");
arrayList.add("sdgd");
arrayList.add("fgdsg");
arrayList.add("f1ds");
for (int i = arrayList.size()-1; i>=0; i--) {
if(methodDelete(arrayList.get(i))==true){
arrayList.remove(i);
}
}
Iterator<String> it = arrayList.iterator();
while (it.hasNext()){
System.out.print(it.next()+" ");
} //3.然后利用迭代器遍历集合元素并输出
} //2.删除集合元素字符串中包含0-9数字的字符串(只要字符串中包含0-9中的任意一个数字就
public static boolean methodDelete(String string){
char[] array = string.toCharArray();
for (int i = 0; i < array.length; i++) {
if (array[i]>=48 && array[i]<=57){
return true;
}
}
return false;
}
}
四:分析以下需求，并用代码实现
1.统计每个单词出现的次数
2.有如下字符串"If you want to change your fate I think you must come to the dark horse to learn java"(用空格间隔)
3.打印格式：
to=3
think=1
you=2
import java.util.HashMap;
import java.util.Map;
import java.util.Set; public class Topic4 {
public static void main(String[] args) {
String str = "If you want to change your fate I think you must come to the dark horse to learn java";
String strArr[] = str.split(" ");
/* for (int i = 0; i < strArr.length; i++) {
System.out.print(strArr[i]+" ");
}*/
HashMap<String,Integer> map = new HashMap<>();
for (String s : strArr) {
/* if (map.containsKey(s)){
//存在
Integer value = map.get(s);
value++;
//不停的覆盖value值
map.put(s,value);
}
else {
//不存在
map.put(s,1);
}*/
// map.put(c,map.containsKey(c)?map.get(c)+1:1);
map.put(s,map.containsKey(s)?map.get(s)+1:1);
}
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
for (Map.Entry<String, Integer> entry : entrySet) {
System.out.println(entry.getKey()+"="+entry.getValue());
}
}
}
五：分析以下需求，并用代码实现
2.定义一个noRepeat()方法,要求对传递过来集合中进行元素去重
public static void noRepeat(List<String> al){
contains
}
import java.util.ArrayList;
import java.util.List; public class Topic5 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("sdgsdg1");
arrayList.add("sdgsdg");
arrayList.add("sdgsdg");
arrayList.add("sdgsdg1");
noRepeat(arrayList);
}
public static void noRepeat(List<String> al){
for (int i = 0; i < al.size(); i++) {
//第一个元素拿出来 如果 后续有元素与之相等,就删除.
String first = al.get(i);
for (int j =i+1;j<al.size();j++)
{
if (first.equals(al.get(j))){
//如果 后面与这个元素相同,就删除后面的元素
al.remove(j);
// j--;
}
}
}
System.out.println(al);
} }
补充部分:
一:简答题:
1. &和&&的区别?
前者是不短路与 ,后者是短路与.
在编写代码的时候,使用a&b,即是a为假,也会对b进行判断.
如果使用的是 a&&b,如果a为假,直接短路得出结果,不会对b进行判断
2.数据类型有哪些?
数据类型分为:基本数据类型、引用数据类型。
基本数据类型：整数型 byte short int long 、浮点型 float double 、字符型 char、布尔型 boolean（四个类别）。
引用数据类型：字符串、数组、类、接口、枚举、Lambda
3.成员变量和局部变量的区别(从作用域,存储位置,初始值,三个方面进行概述)
（1）定义的位置
局部变量：在方法的小括号或者大括号
成员变量：在类中方法外
（2）作用域（范围）
局部变量：只能在所在的方法中
成员变量：在整个类中
（3）默认值
局部变量：没有默认值，使用之前必须先赋值，否则就报错
成员变量：有默认值
（4）内存中的位置
局部变量：跟着方法进入栈内存
成员变量：跟着对象进入堆内存
（5）生命周期
局部变量：随着方法的进栈而存在，随着方法的出栈而消失，立刻回收
成员变量：随着对象的创建而存储，随着对象被垃圾回收机制回收而消失，在合适的时候回收
4. 线程和进程有什么区别和联系?
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
5. 实现多线程的方式以及区别:
方式一:继承Thread类
方式二:实现Runnable接口
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
6.start()和run方法有什么区别？
start()：该方法是在当前线程中启动一个新的线程，而新启动的线程会调用run()方法，同时该方法不能重复调用；
run() ：该方法和普通的方法一样，可以重复执行，不会创建新的线程。
7.Map集合的两种遍历方式:
(1)第一种方式通过键找值,因为map中键是唯一的.使用keySet()方法返回Map中的所有键.
食用方式: Set<数据类型> keys = map.keySet();
(2)通过Entry键值对对象进行遍历
食用方式:Set<Entry<类型1,类型2> entrySet = map.entrySet();
然后遍历entrySet集合就行
for(Entry<类型1,类型2> entry: entrySet)
1.：根据需求完成代码:
1.定义动物类
属性：
年龄，颜色
行为:
eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)
生成空参有参构造，set和get方法
2.定义狗类继承动物类
行为:
eat(String something)方法,看家lookHome方法(无参数)
3.定义猫类继承动物类
行为:eat(String something)方法,逮老鼠catchMouse方法(无参数)
4.定义Person类
属性：
姓名，年龄
行为：
keepPet(Dog dog,String something)方法
功能：喂养宠物狗，something表示喂养的东西
行为：
keepPet(Cat cat,String something)方法
功能：喂养宠物猫，something表示喂养的东西
生成空参有参构造，set和get方法
5.定义测试类(完成以下打印效果):
keepPet(Dog dog,String somethind)方法打印内容如下：
年龄为30岁的老王养了一只黑颜色的2岁的宠物
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
keepPet(Cat cat,String somethind)方法打印内容如下：
年龄为25岁的老李养了一只灰颜色的3岁的宠物
3岁的灰颜色的猫眯着眼睛侧着头吃鱼
6.思考：
1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？
2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法？
定义Animal类:
package topic1;
public abstract class Animal {
/*年龄，颜色*/
private int age;
private String color;
/*eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)*/
public abstract void eat(String something);
/* 生成空参有参构造，set和get方法*/
public Animal() {
}
public Animal(int age, String color) {
this.age = age;
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
Cat类
package topic1;
public class Cat extends Animal {
@Override
public void eat(String something) {
System.out.println("眯着眼睛侧着头"+something);
}
public void CatchMouse(){
System.out.println("猫正在抓老鼠");
}
public Cat() {
}
public Cat(int age, String color) {
super(age, color);
}
}
Dog类
package topic1;
public class Dog extends Animal {
@Override
public void eat(String something) {
System.out.println("两只前腿死死的抱住"+something+"猛吃");
}
public void lookHome(){
System.out.println("狗正在看家");
}
public Dog() {
}
public Dog(int age, String color) {
super(age, color);
}
}
Person类
package topic1;
import java.text.DateFormat;
public class Person {
/* 姓名，年龄*/
private String name;
private int age;
/*行为：
keepPet(Dog dog,String something)方法
功能：喂养宠物狗，something表示喂养的东西
*/
/* public void keepPet(Dog dog,String something){
System.out.printf("年龄为%d的%s养了一只%s颜色的%d岁的宠物",this.age,this.name,dog.getColor(),dog.getAge());
System.out.printf("%d岁的%s的狗两只前腿死死的包住骨头猛吃",dog.getAge(),dog.getColor());
}
public void keepPet(Cat cat,String something){
System.out.printf("年龄为%d的%s养了一只%s颜色的%d岁的宠物",this.age,this.name,cat.getColor(),cat.getAge());
System.out.printf("%d岁的%s的猫眯着眼睛侧着头吃鱼",cat.getAge(),cat.getColor());
}*/
public void keepPet(Object obj,String something){
if(obj instanceof Dog){
System.out.printf("年龄为%d的%s养了一只%s颜色的%d岁的宠物\n",this.age,this.name,((Dog) obj).getColor(),((Dog) obj).getAge());
System.out.printf("%d岁的%s颜色的狗",((Dog) obj).getAge(),((Dog) obj).getColor());
((Dog) obj).eat(something);
}
else if ((obj instanceof Cat)){
System.out.printf("年龄为%d的%s养了一只%s颜色的%d岁的宠物\n",this.age,this.name,((Cat) obj).getColor(), ((Cat) obj).getAge());
System.out.printf("%d岁的%s颜色的猫",((Cat) obj).getAge(),((Cat) obj).getColor());
((Cat) obj).eat(something);
}
}
/*生成空参有参构造，set和get方法 */
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
}
测试类:
package topic1;
public class TestClass {
public static void main(String[] args) {
Person p = new Person("老王",30);
Person p2 = new Person("老李",25);
Dog dog = new Dog(2,"黑");
Cat cat = new Cat(3,"灰");
p.keepPet(dog,"骨头");
p2.keepPet(cat,"吃鱼");
}
}
2.产生10个长度为10的不能重复的字符串(里面只能出现大写字母、小写字母、0-9的数字)，并遍历打印输出
package topic2; import java.util.LinkedHashSet;
import java.util.Random; public class Topic2 {
public static void main(String[] args) {
method3();
}
private static void method3() {
LinkedHashSet<String> set = new LinkedHashSet<>();
while(set.size()<10)
{
set.add(makeArray()); }
System.out.println(set); }
/*产生长度为10的不能重复的字符串(里面只能出现大写字母、小写字母、0-9的数字)*/
private static String makeArray(){
String strValue = "";
//1.先创建一个字符数组，题目要求长度为10，即是字符数组的上限为10
char array[] = new char[10];
//2.随机生成 一个flag标记值,用来随机生成 小写字母 大写字母 数字
Random ra = new Random();
for (int i = 0; i < array.length; i++) {
//获得flag标记值
//flag为 0 标记 整数
//flag为 1 标记 小写字母
//flag为 2 标记 大写字母 int flag = ra.nextInt(3);
if (flag == 0)
{
int zhengshu = new Random().nextInt(10);
array[i]=(char)(48+zhengshu); }
else if (flag ==1){
int xiaoxie = new Random().nextInt(26);
array[i]=(char)('a'+xiaoxie);
}
else
{
int daxie = new Random().nextInt(26);
array[i]=(char)('A'+daxie);
}
}
for (int i = 0; i < array.length; i++) {
strValue+=array[i];
}
return strValue;
} }
3.键盘录入一个字符串,统计每个字母出现的次数（不用按照字母的顺序排列），按照如下格式打印：
* a(10)b(2000)c(30)d(400)...
package topic3;
import java.util.*;
public class Topic3 {
public static void main(String[] args) {
System.out.println("请输入随便一个字符串");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
method1(str);
}
private static void method1(String str) {
//1. 创建Map集合,key是字符串中的字符,value是字符的个数
//由于HashMap具有筛选功能,可以帮助我们对字符进行统计.
HashMap<Character,Integer> map = new HashMap<>();
//2.将形式参数传递过来的字符串使用toCharArray()的方法转换成Char类型的字符数组.c用来遍历获取字符数组中的每一个值.
for(char c :str.toCharArray()){
//对于字符串"abcbcd"为例,char c =a; map.containKey(a)为false,执行:号后的1
//map.put(a,1); 这样就将a字符与对应的数量添加到了map集合中.
map.put(c,map.containsKey(c)?map.get(c)+1:1);
}
/* //获取最后一个key
Set<Character> chrs = map.keySet();
List list = new ArrayList(chrs);
char lastKey = (char)(list.get(list.size()-1));*/
//char lastKey = (char)list.lastIndexOf("d");
// System.out.println(lastKey);
for(Map.Entry<Character,Integer> entry : map.entrySet()){
char key = entry.getKey();
int value = entry.getValue();
//如果是最后一个key直接打印key与value结束.
/* if (key == lastKey)
{
System.out.println(key+"="+value);
break;
}*/
//如果不是最后一个,打印 key与value和一个逗号分隔
System.out.print(key+"("+value+")");
}
}
}
4.分析以下需求，并用代码实现 定义Student类包含姓名：String name、年龄：int age、成绩：int
* score，生成空参、有参构造、set和get方法、toString方法
1.创建10个学生对象(其中有两个学员信息完全相同)存入集合中
2.去除重复的学员并遍历打印剩余学员信息
3.打印最高分的学员信息
4.打印平均分
5.打印不及格的学员信息及数量
创建一个Student类
package topic4;
public class Student {
/*姓名：String name、年龄：int age、成绩：int*/
private String name;
private int age;
private int score;
/*生成空参、有参构造、set和get方法、toString方法*/
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
public Student() {
}
}
测试类:
package topic4;
import java.util.ArrayList;
public class Topic4 {
public static void main(String[] args) {
/* 1.创建10个学生对象(其中有两个学员信息完全相同)存入集合中*/
ArrayList<Student> arrayList = new ArrayList<>();
arrayList.add(new Student("学生1",18,90));
arrayList.add(new Student("学生2",18,80));
arrayList.add(new Student("学生3",18,70));
arrayList.add(new Student("学生4",18,60));
arrayList.add(new Student("学生5",18,50));
arrayList.add(new Student("学生6",18,40));
arrayList.add(new Student("学生7",18,30));
arrayList.add(new Student("学生8",18,20));
arrayList.add(new Student("学生9",18,10));
arrayList.add(new Student("学生1",18,90));
/*2.去除重复的学员并遍历打印剩余学员信息*/
int delFlag =0;//重复删除元素标记
int highScoreFlag=0;//最高分标记
int count=0;//总成绩
for (int i = 0; i < arrayList.size(); i++) {
for(int j=1;j<arrayList.size();j++){
if (arrayList.get(i)==arrayList.get(j))
{
delFlag=j;
}
}
}
//删除重复学员
arrayList.remove(delFlag);
for (Student student : arrayList) {
System.out.println(student);
}
// 3.打印最高分的学员信息
int score = arrayList.get(1).getScore();
for (int i = 1; i < arrayList.size(); i++) {
if (arrayList.get(i).getScore()>score)
{
// score=arrayList.get(i).getScore();
highScoreFlag=i;
}
}
System.out.println("最高分的学员为"+arrayList.get(highScoreFlag));
// 4.打印平均分
for (int i = 0; i < arrayList.size(); i++) {
count+=arrayList.get(i).getScore();
}
System.out.println("平均分为"+(double)count/(double)arrayList.size());
// 5.打印不及格的学员信息及数量
int bujigeCount=0;
System.out.println("不及格的人为:");
for (int i = 0; i < arrayList.size(); i++) {
if (arrayList.get(i).getScore()<60)
{
System.out.print(arrayList.get(i).getName()+" ");
bujigeCount++;
}
}
System.out.println("不及格的总人数为"+bujigeCount);
}
}