【Programming Abstractions in Java课后习题3】数组、集合

最新推荐文章于 2024-08-16 23:08:28 发布

三金C_C

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量374

点赞数

分类专栏： Java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/QAZJOU/article/details/122455053

版权

Java 专栏收录该内容

24 篇文章 18 订阅

订阅专栏

课后习题2
课后习题1

教材是Programming Abstractions in Java， Eric.S.Roberts——Java程序设计基础、编程抽象与算法策略。
你的三连就是我创作的最大动力！

两节笔记

数组

1.数组声明

type[] name=new type[size];

常量声明

public static final int N=5;
int a=new int[5];

2.Java数组索引从0开始，有一个length域，包含了元素的数量。
3.在机器语言级别上，用来表示内存内容的地址叫指针，而java中，用于传统的术语叫引用。并且，在参数传递过程复制的是对数组的引用。
4.信息基础单元（状态，例如0，1）叫位（bit），最小的组合单元称为字节，有8位构成，足以存储一个char。
5.十进制常量写为标准形式的，八进制常量前有引导0，而十六进制有前导0x.
6.数组被表示为对某个内存结构的引用，该内存结构中包含数组的长度、元素的数据和一些客户端无法访问的附加信息。
7.Java中，int 4字节，float 4字节，double 8字节 long 8字节
8.可变长参数列表

private int max(int n1,int...args){
        int res=n1;
        for(int n:args){
            if(res<n) res=n;
        }
        return res;
    }

如果调用max(3,17,42,19)，则返回42.
注意args绑定了17，42，19的数组。

ArrayList类

import java.until.ArrayList;
9.声明ArrayList对象(构造器)：

ArrayList<String> list=new ArrayList<String>();

10.常用方法

方法	功能
size()	返回数量
isEmpty()	如果ArrayList空则返回true
get(index)	返回索引的值
get(index,value)	将索引的值设置为新值
add(value)	末尾加值
add(index,value)	在指定索引前插入新值
remove(index/value)	移除
clear	清除

包装器类

这些类定义在java.lang包中
11.ArrayList类对于存储String类或者其他Java类的值非常合适，但是无法直接使用int,double基本类型。基本类型不是对象，而ArrayList的值必须是对象。

基本类型	包装器类
boolean	Boolean
float	Float
double	Double
int	Integer
long	Long
char	Character

12.声明

Integer a=new Integer(n);

创建Integer对象，内部值为n，赋给了变量a。
引用他的值

a.value();

所以这样可以使用ArrayList类了

ArrayList<a> m;

13.自动装箱：当Java编译器发现我们试图将Int类型的值赋给Integer类型时，会自动创建一个Integer对象，反过来也成立。
所以可以用==与！=用于对象，检查运算符两侧的操作数是否引用了同一个对象。
14.静态方法：

方法	功能
Integer.paseInt(string,base(可省略))	将字符串转换为整数，如果有数基则进行转换
Integer.toString(number,base(可省略))	将数字转换为字符串形式

int x =Integer.parseInt("9");//然后引用x

栈抽象

栈在编程中很重要，主要原因是嵌套函数调用的行为方式就是面向栈的方式。
Stack也是一个指定元素类型的集合类。
声明同上
15.主要方法

方法	功能
size()	元素数量
isEmpty()	栈空返回true
push(value)	将value压入栈，使它成为顶部
pop()	出栈
peek()	返回最顶部的栈
clear()	清除所有元素

队列抽象

16.注意，Stack是类，但是Queue是一个接口，在Java中，接口时一种数据结构的定义，刻画了操作但是没有顶层的表示形式。接口指定了其他实现该接口的类的行为。
Queue接口的具体类，一般常见的是ArrayDeque(双端队列)和LinkedList.
声明：

Queue<Integer> queue=new ArrayDeque<Integer>();

17。主要方法

方法	功能
size()	数量
isEmpty()	空为true
add(value)	入队
remove()	出队
peak	返回队首

映射表抽象

18.Map是一个接口，所以同样要用类来构建对象。主要有HashMap和TreeMap

Map<String,String> dict=new TreeMap<String,String>();

19.主要方法

方法	功能
put(key,value)	将key与value关联，如果没有key那么会添加一项
get(key)	返回该映射表当前与key关联的值
remove(key)	删除key及相关联的值
containsKey(key)	如果key与某个值关联则返回

迭代器

20.迭代元素对任何集合类来说是基础操作。

Set<String> english=new Treeset<String>();
for(String word:english){
	if(word.length()==7){
		System.out.println(word);
	}
}

部分习题选讲

这一部分还有许多习题值得去做，在这里仅挑选非常重要的来讲，下次更新更多很好的题目。

ArrayList反序

题目：使用ArrayList以反序显示文件中各行

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class ReverseFile {

   public void run() {
      Scanner sysin = new Scanner(System.in);
      try {
         BufferedReader rd = openFileReader(sysin, "Input file: ");
         ArrayList<String> lines = readEntireFile(rd);
         rd.close();
         for (int i = lines.size() - 1; i >= 0; i--) {
            System.out.println(lines.get(i));
         }
      } catch (IOException ex) {
         throw new RuntimeException(ex.toString());
      }
   }


   private ArrayList<String> readEntireFile(BufferedReader rd) {
      try {
         ArrayList<String> lines = new ArrayList<String>();
         while (true) {
            String line = rd.readLine();
            if (line == null) break;
            lines.add(line);
         }
         return lines;
      } catch (IOException ex) {
         throw new RuntimeException(ex.toString());
      }
   }

   private BufferedReader openFileReader(Scanner sysin, String prompt) {
      BufferedReader rd = null;
      while (rd == null) {
         try {
            System.out.print(prompt);
            String name = sysin.nextLine();
            rd = new BufferedReader(new FileReader(name));
         } catch (IOException ex) {
            System.out.println("Can't open that file.");
         }
      }
      return rd;
   }

/* Main program */

   public static void main(String[] args) {
      new ReverseFile().run();
   }

}

RPN计算器（栈）

题目描述：逆波兰标记法输入表达式（RPN），使用java来编写此程序。

import java.util.Scanner;
import java.util.Stack;

public class RPNCalculator {

   public void run() {
      Scanner sysin = new Scanner(System.in);
      System.out.println("RPN Calculator Simulation (type H for help)");
      Stack<Double> operandStack = new Stack<Double>();
      while (true) {
         System.out.print("> ");
         String line = sysin.nextLine();
         char ch = Character.toUpperCase(line.charAt(0));
         if (ch == 'Q') {
            break;
         } else if (ch == 'C') {
            operandStack.clear();
         } else if (ch == 'H') {
            helpCommand();
         } else if (Character.isDigit(ch)) {
            operandStack.push(Double.parseDouble(line));
         } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
            applyOperator(ch, operandStack);
         } else {
            System.out.println("Unrecognized command " + ch);
         }
      }
   }

   private void helpCommand() {
      System.out.println("Enter expressions in Reverse Polish Notation,");
      System.out.println("in which operators follow the operands to which");
      System.out.println("they apply.  Each line consists of a number, an");
      System.out.println("operator, or one of the following commands:");
      System.out.println("  Q -- Quit the program");
      System.out.println("  H -- Display this help message");
      System.out.println("  C -- Clear the calculator stack");
   }

   private void applyOperator(char op, Stack<Double> operandStack) {
      double result;
      double rhs = operandStack.pop();
      double lhs = operandStack.pop();
      switch (op) {
       case '+': result = lhs + rhs; break;
       case '-': result = lhs - rhs; break;
       case '*': result = lhs * rhs; break;
       case '/': result = lhs / rhs; break;
       default: throw new RuntimeException("Undefined operator " + op);
      }
      System.out.println(result);
      operandStack.push(result);
   }

/* Main program */

   public static void main(String[] args) {
      new RPNCalculator().run();
   }

}

计算词频（Map）

题目描述：编写一个java程序，使得计算输入文件每个单词的出现次数。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class WordFrequency {

   public void run() {
      Scanner sysin = new Scanner(System.in);
      try {
         BufferedReader rd = openFileReader(sysin, "Input file: ");
         Map<String,Integer> wordCounts = new TreeMap<String,Integer>();
         while (true) {
            String line = rd.readLine();
            if (line == null) break;
            countWords(line, wordCounts);
         }
         rd.close();
         displayCounts(wordCounts);
      } catch (IOException ex) {
         throw new RuntimeException(ex.toString());
      }
   }



   private void countWords(String line, Map<String,Integer> wordCounts) {
      String word = "";
      for (int i = 0; i < line.length(); i++) {
         char ch = line.charAt(i);
         if (Character.isLetter(ch)) {
            word += Character.toLowerCase(ch);
         } else {
            if (!word.isEmpty()) {
               incrementCount(word, wordCounts);
               word = "";
            }
         }
      }
      if (!word.isEmpty()) incrementCount(word, wordCounts);
   }

/*
 * Increments the count for word in the map.
 */

   private void incrementCount(String word, Map<String,Integer> wordCounts) {
      if (wordCounts.containsKey(word)) {
         wordCounts.put(word, wordCounts.get(word) + 1);
      } else {
         wordCounts.put(word, 1);
      }
   }

/*
 * Displays the word count along with the word.
 */

   private void displayCounts(Map<String,Integer> wordCounts) {
      for (String word : wordCounts.keySet()) {
         System.out.printf("%4d  %s%n", wordCounts.get(word), word);
      }
   }

   private BufferedReader openFileReader(Scanner sysin, String prompt) {
      BufferedReader rd = null;
      while (rd == null) {
         try {
            System.out.print(prompt);
            String name = sysin.nextLine();
            rd = new BufferedReader(new FileReader(name));
         } catch (IOException ex) {
            System.out.println("Can't open that file.");
         }
      }
      return rd;
   }

/* Main program */

   public static void main(String[] args) {
      new WordFrequency().run();
   }

}

总结

此次java学习结合了重要的数据结构来进行讲解，可以很直观的发现java与C++异同。然而对于java的学习理解这些还远远不够，这些也只是最基础的部分，尽管后期书籍以算法讲解较多，但是涉及java的框架还是谈的比较少，所以在后期的学习中，应该加大java的实战项目经验，通过前后端的连接来理解java的重要性！

三金C_C

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Programming Abstractions in Java课后习题3】数组、集合

在Java中，数组很重要，但是有没有更好的类呢？同样的，Java中关于数据抽象的还有哪些呢？点击一下，带你走进不一样的世界——更好的总结知识！
复制链接

扫一扫

专栏目录