java编程思想第四版第十一章习题
- 第一题
package net.mindview.holding.test1; import java.util.ArrayList;
import java.util.List; /**
* 沙鼠
* @author samsung
*
*/
public class Gerbil {
static int counter;
int gerbilNumber; public Gerbil(){
this.gerbilNumber = counter ++;
} public String hop(){ return "沙鼠的号码:"+gerbilNumber + ",正在跳跃";
} public static void main(String[] args) {
List<Gerbil> list = new ArrayList<Gerbil>();
list.add(new Gerbil());
list.add(new Gerbil());
list.add(new Gerbil());
list.add(new Gerbil());
for(Gerbil g: list){
System.out.println(g.hop());
}
}
}运行结果
沙鼠的号码:,正在跳跃
沙鼠的号码:,正在跳跃
沙鼠的号码:,正在跳跃
沙鼠的号码:,正在跳跃 - 第二题
package net.mindview.holding.test2; import java.util.HashSet;
import java.util.Set; public class SimpleCollection { public static void main(String[] args) {
Set<Integer> c = new HashSet<Integer>();
for(int i = ; i < ; i++){
c.add(i);
}
for(Integer i: c){
System.out.print(i + ",");
}
} } - 第三题
package net.mindview.holding.test3; import java.util.ArrayList;
import java.util.List; /**
* 选择器
*/
interface Selector {
//是否结束
boolean end();
//当前
Object current();
//下一个
void next();
} /**
* 顺序
*/
public class Sequence {
//数组是有限制的,而集合时无限制的.
//private Object[] items;
private List<Object> items;
private int next = ;
//定义数组的个数
public Sequence(){
items = new ArrayList<Object>();
}
//添加
public void add(Object x){
items.add(x);
} //内部类--顺序选择器
private class SequenceSelector implements Selector {
//选择器最开始指向第一个元素
private int i = ;
@Override
public boolean end() {
return i == (items.size());
}
/**
* 新增方法: 在内部类中引用外部类
*/
public Sequence outer(){
return Sequence.this;
} @Override
public Object current() {
return items.get(i);
} @Override
public void next() {
if(i<items.size()){
i++;
}
}
} public Selector selector() {
return new SequenceSelector();
} public static void main(String[] args) {
Sequence s = new Sequence();
for(int i=; i<; i++){
s.add("对象"+i);
}
Selector selector = s.selector();
while(!selector.end()){
System.out.print(selector.current());
selector.next();
}
} }结果
对象0对象1对象2对象3对象4对象5对象6对象7对象8对象9
分析： 这个案例的重点是， 数组瘦受限制的， 集合是没有元素个数限制的。 因此，可以任意添加元素的意思就是：将数组替代为集合。
- 第四题
package net.mindview.holding.test4; import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.TreeSet;
class MoiveNameGenerator {
String[] moives = {"Snow White", "Star Wars", "White Princple", "Dream","My Mother", "The Forest", "My Grandpa"};
int next;
public String next(){
String moive = moives[next];
//电影名用完之后, 循环到这个字符列表的开始处
next = (next+) % moives.length;
return moive;
} }
public class MoiveGenerator {
MoiveNameGenerator moiveNameGenerator = new MoiveNameGenerator();
public String[] fill(String[] arr){
for(int i=; i<arr.length; i++){
arr[i] = moiveNameGenerator.next();
}
return arr;
} public Collection fill(Collection col){
for(int i=; i<; i++){
col.add(moiveNameGenerator.next());
}
return col;
} public static void main(String[] args) {
MoiveGenerator moiveGenerator = new MoiveGenerator();
System.out.println(Arrays.toString(moiveGenerator.fill(new String[])));
System.out.println(moiveGenerator.fill(new ArrayList<String>()));
System.out.println(moiveGenerator.fill(new LinkedList<String>()));
System.out.println(moiveGenerator.fill(new HashSet<String>()));
System.out.println(moiveGenerator.fill(new LinkedHashSet<String>()));
System.out.println(moiveGenerator.fill(new TreeSet<String>()));
}
}运行结果：
[Snow White, Star Wars, White Princple, Dream, My Mother]
[The Forest, My Grandpa, Snow White, Star Wars, White Princple]
[Dream, My Mother, The Forest, My Grandpa, Snow White]
[My Mother, Star Wars, The Forest, Dream, White Princple]
[My Grandpa, Snow White, Star Wars, White Princple, Dream]
[My Grandpa, My Mother, Snow White, Star Wars, The Forest] - dff
- af
- a
- fa
- fda
- sf
- af
- as
- fa
- fa
栈在编程语言中,经常用来对表达式求值。请使用net.mindview.util.Stack对下面的表达式求值。 其中“+”表示将后面的字母压入栈，“-”表示将栈顶的字母押出栈。并打印他们。
package net.mindview.holding; import java.util.LinkedList; /**
* 模拟栈
*/
public class Stack<T> {
private LinkedList<T> storage = new LinkedList<T>(); //推入
public void push(T v){
storage.addFirst(v);
} public T peek(){
return storage.getFirst();
} //取出
public T pop(){
return storage.removeFirst();
} public boolean empty(){
return storage.isEmpty();
} public String toString(){
return storage.toString();
} }package net.mindview.holding.test15; import java.util.Stack; /**
* 栈在编程语言中,经常用来对表达式求值。请使用net.mindview.util.Stack对下面的表达式求值。
* 其中“+”表示将后面的字母压入栈，“-”表示将栈顶的字母押出栈。并打印他们。
* @author samsung
*
*/
public class Test15 {
Stack<Character> stac = new Stack<Character>();
//计算
public void eval(String str){
char[] chars = str.toCharArray();
for(int i=; i<chars.length; i++){
char c = chars[i++];
//遇到+号把字符入栈
switch (c){
case '+':
System.out.println("入栈:"+stac.push(chars[i]));
break;
case '-':
System.out.println("出栈:"+stac.pop());
break;
}
}
} public static void main(String[] args) {
Test15 t = new Test15();
String str = "+U+n+c---+e+r+t---+a-+i-+n+t+y---+ -+r+u--+l+e+s--";
t.eval(str);
}
}- fda
- fa
- fa
- dfa
- fa
- df
- asfd
- afa
- fa
- fa
- fa
- 二十七题
package net.mindview.holding.test27; import java.util.LinkedList;
import java.util.Queue; //消息
class Command {
String str;
public Command(String str){
this.str = str;
}
public void operation(){
System.out.println(str);
}
} //生产者
class Producter{
//生产者生成消息
public Queue<Command> produce(Queue<Command> qc){
qc.offer(new Command("A"));
qc.offer(new Command("AB"));
qc.offer(new Command("ABC"));
qc.offer(new Command("VFA"));
qc.offer(new Command("SDA"));
return qc;
}
} //消费者
class Customer {
//消费者消费消息
public void custom(Queue<Command> queue){
while(queue.peek() != null){
queue.remove().operation();
}
}
} public class Test27 {
public static void main(String[] args) {
Queue<Command> qc = new LinkedList<Command>();
Producter producter = new Producter();
Queue<Command> qcc = producter.produce(qc);
new Customer().custom(qcc); }
}运行结果:
A
AB
ABC
VFA
SDA - fa
- 第三十一题
package net.mindview.holding.test31; import java.util.Iterator;
import java.util.Random; //形状
class Shape {
public void draw() {
} public void erase() {
}
} // 圆形
class Cycle1 extends Shape { @Override
public void draw() {
System.out.println("draw cycle");
} @Override
public void erase() {
System.out.println("erase cycle");
} } class Square extends Shape {
@Override
public void draw() {
System.out.println("draw Square");
} @Override
public void erase() {
System.out.println("draw Square");
}
} // 矩形
class Triangle extends Shape {
@Override
public void draw() {
System.out.println("draw Triangle");
} @Override
public void erase() {
System.out.println("draw Triangle");
}
} // 梯形
class Trapezoid extends Shape {
@Override
public void draw() {
System.out.println("draw Trapezoid");
} @Override
public void erase() {
System.out.println("draw Trapezoid");
}
} class RandomShapeFactory implements Iterable<Shape> {
Random random = new Random(); private final int quantity; public RandomShapeFactory(int quantity) {
this.quantity= quantity;
} // 下面画什么形状呢
public Shape nextShape() {
switch (random.nextInt()) {
default:
case :
return new Cycle1();
case :
return new Square();
case :
return new Triangle();
case :
return new Trapezoid();
}
} @Override
public Iterator<Shape> iterator() {
return new Iterator<Shape>() {
private int count = ; @Override
public boolean hasNext() {
return count < quantity;
} @Override
public Shape next() {
++count;
return nextShape();
} @Override
public void remove() { }
};
}
} public class Shapes {
public static void main(String[] args) {
RandomShapeFactory rd = new RandomShapeFactory();
for (Shape s : rd) {
System.out.println(s.getClass().getSimpleName());
} } }运行结果
Triangle
Square
Triangle
Cycle1
Cycle1
Triangle
Cycle1
Square
Triangle - f
- afda
java编程思想第四版第十一章习题的更多相关文章
- java编程思想第四版第十一章总结
1. 容器类被分为两类:Collection和Map Collection是一个接口:包括: List接口: ArrayList:按照被插入顺序保存元素, 查询快, 增删改慢 LinkedList:按 ...
- java编程思想第四版第六章习题
(略) (略) 创建两个包:debug和debugoff,他们都包含一个相同的类,该类有一个debug()方法,第一个版本显示发送给控制台的String参数,而第二版本什么也不做,使用静态import ...
- java编程思想第四版第五章习题
创建一个类, 它包含一个未初始化的String引用.验证该引用被Java初始化成了null package net.mindview.initialization; public class Test ...
- java编程思想第四版第七章习题
(略) (略) (略) (略) 创建两个带有默认构造器(空参数列表)的类A和类B.从A中继承产生一个名为C的新,并在C内创建一个B类的成员.不要给C编写构造器.创建一个C类的对象并观察其结果. pac ...
- java编程思想第四版第十三章字符串 习题
fas 第二题 package net.mindview.strings; import java.util.ArrayList; import java.util.List; /** * 无限循环 ...
- Java编程思想第四版*第七章*个人练习
欢迎加群:239063848 成团的笔记:该组仅用于技术共享和交流,问题和答案公布 潘基聊天.禁止广告.禁止招聘-- 练习1:(2)创建一个简单的类.第二个类中,将一个引用定义为第一个类的对象.运用惰 ...
- java编程思想第四版第六章总结
1. 代码重构 为什么f要代码重构 第一次代码不一定是完美的, 总会发现更优雅的写法. 代码重构需要考虑的问题 类库的修改不会破坏客户端程序员的代码. 源程序方便扩展和优化 2. 包 创建一个独一无二 ...
- java编程思想 第四版 第六章 个人练习
欢迎加群:239063848 进群须知:本群仅用于技术分享与交流.问题公布与解答 禁止闲聊.非诚勿扰 练习1:(1)在某个包中创建一个类,在这个类所处的包的外部创建该类的一个实例. import mi ...
- java编程思想第四版第十三章字符串 总结
1. String和StringBulider的使用 通过书中介绍, 我们得知如下结论: 当使用+连接符将字符串进行拼接的时候, 编译器会进行自动优化为使用StringBuilder连接字符串. 当在 ...
随机推荐
- Java学习笔记之基础语法(顺序，条件，循环语句)
顺序结构:自上而下 条件分支选择结构: if条件语句 1,一旦某一个分支确定执行以后,其他分支就不会执行.if后面的条件必须是boolean类型 2,if 后面如果不加大括号,默认相邻的下一 ...
- PMBOK(第六版) PMP笔记-质量审计、风险审计、采购审计的区分
质量审计.风险审计.采购审计的区分 三个概念的相同之处: 都是审计的概念 都是特定知识领域的审计 三个概念的区别: (1)三个概念虽然都是审计,但分布在不同的管理过程组. ·质量审计:执行过程组, ...
- Express框架的整体感知
Express是基于node.js平台的快速.开放.极简的web开放框架,它的地位与作用有点类似于前端的jquery框架.它的英文官网地址为 http://expressjs.com,其对应的中文官网 ...
- Halcon一日一练：图像采集设备的基本参数
因操作图像处理之前,需要对图像进行采集.采集图像,我们首先要确定的是图像的像素和采集的效率.这些都需要对设备进行配置与操作.现实情况是图像设备有各自不同的采集方式,配置也各不相同.这就需要设备提供商提 ...
- halcon小结
持更 应用范围 (罗列自官方帮助文档,以后有空了按照需求展开叙述) 1. 安全系统 2. 表面检测 3. 定位 4. 二维测量比较 5. 二维码识别 6. 二维位置定位 7. 二维物体识别 8. 光学 ...
- java日志空指针怎么定位问题
示例报错: java.lang.NullPointerException: null at com.ipharmacare.sf.task.service.MatchAuditPlanService. ...
- 推荐一款现代化的脚手架项目《hope-boot》
简介: > 一款现代化的脚手架项目.企业开发?接外包?赚外快?还是学习?这都能满足你,居家必备,值得拥有
- 斯坦福机器学习课程 Exercise 习题三
Exercise 3: Multivariate Linear Regression 预处理数据 Preprocessing the inputs will significantly increas ...
- python常用算法（7）——动态规划，回溯法
引言:从斐波那契数列看动态规划 斐波那契数列:Fn = Fn-1 + Fn-2 ( n = 1,2 fib(1) = fib(2) = 1) 练习:使用递归和非递归的方法来求解斐波那契数 ...
- 如何用好redis pipeline
编者注:pipeline是Redis的一个提高吞吐量的机制,适用于多key读写场景,比如同时读取多个key的value,或者更新多个key的value.工作过程中发现挺多小伙伴都对pipeline多少 ...