Java语言程序设计与数据结构（基础篇）课后练习题 第十章（一）

}

public boolean isEven() {

return isEven(value);

}

public boolean isOdd() {

return isOdd(value);

}

public boolean isOdd(int value) {

if (value % 2 != 0)

return true;

else

return false;

}

public boolean isPrime() {

return isPrime(value);

}

public static boolean isPrime(int value) {

for (int i = 2; i < value - 1; i++)

if (value % i == 0)

return false;

return true;

}

public static boolean isEven(MyInteger m) {

if (m.getValue() % 2 == 0)

return true;

else

return false;

}

public static boolean isOdd(MyInteger m) {

if (m.getValue() % 2 != 0)

return true;

else

return false;

}

public static boolean isPrime(MyInteger m) {

for (int i = 2; i < m.getValue() - 1; i++) {

if (m.getValue() % 2 == 0)

return false;

}

return true;

}

public boolean equals(int value) {

if (this.value == value)

return true;

else

return false;

}

public boolean equals(MyInteger m) {

if (this.value == m.getValue())

return true;

else

return false;

}

}

10.4

=================================================================

public class dishizhang {

public static void main(String[] args) {

// TODO Auto-generated method stub

MyPoint p1 = new MyPoint(0,0);

MyPoint p2 = new MyPoint(10,30.5);

System.out.println("The distance is "+p1.distance(p2));

}

}

class MyPoint{

private double x;

private double y;

MyPoint(){

this.x = 0.0;

this.y = 0.0;

}

public MyPoint(double x,double y){

this.x = x;

this.y = y;

}

public double distance(double x,double y){

double s;

s = Math.sqrt((this.x - x)(this.x - x)+(this.y - y)(this.y - y));

return s;

}

public double distance(MyPoint mypoint){

double s;

s = Math.sqrt((this.x - mypoint.getX()) * (this.x - mypoint.getX())+(this.y - mypoint.getY()) * (this.y - mypoint.getY()));

return s;

}

public double getX(){

return x;

}

public double getY(){

return y;

}

}

10.5

=================================================================

import java.util.Arrays;

import java.util.Scanner;

public class dishizhang {

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.print(“Please input a integer :”);

Scanner input = new Scanner(System.in);

int integer=input.nextInt();

StackOfIntegers stackOfIntegers = new StackOfIntegers(integer);

int[] i=stackOfIntegers.Prime();

System.out.print("All the prime factors of the “+integer+ " are :”);

System.out.print(Arrays.toString(i));

}

}

class StackOfIntegers{

private int integer;

public StackOfIntegers(int integer) {

this.integer = integer;

}

private static int k = 0;

private static int l = 0;

public int[] GetPrime() {

int[] getPrime = new int[this.integer];

boolean isPrime = true;

for (int i = 2; i < this.integer; i++) {

for (int j = 2; j < i; j++) {

if (i % j == 0) {

isPrime = false;

break;

}

}

if (isPrime) {

getPrime[k] = i;

k++;

} else isPrime = true;

}

return getPrime;

}

public int[] Prime() {

int[] get = GetPrime();

int[] prime1 = new int[k];

boolean judge=false;

while (this.integer != 0) {

for (int a = k - 1; a >= 0; a–) {

if ((int) (this.integer / get[a]) == (double) this.integer / get[a]) {

prime1[l] = get[a];

this.integer /= get[a];

l++;

}

if (integer == get[a] || integer == 1) {

prime1[l] = get[a];

judge=true;

break;

}

}

if (judge)

break;

}

int[] prime=new int[l+1];

for (int i=0;i<l+1;i++){

prime[i]=prime1[i];

}

Arrays.sort(prime);

return prime;

}

}

10.6

=================================================================

import java.util.Arrays;

import java.util.Scanner;

public class dishizhang {

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.print(“Please input a integer :”);

Scanner input = new Scanner(System.in);

int integer=input.nextInt();

StackOfIntegers stackOfIntegers = new StackOfIntegers(integer);

int[] i = stackOfIntegers.GetPrime();

System.out.print("All primes less than "+integer+ " are: ");

for(int j=0;j<i.length;j++){

if(i[j]!=0)

System.out.print(i[j]+" ");

}

}

}

class StackOfIntegers{

private int integer;

public StackOfIntegers(int integer) {

this.integer = integer;

}

private static int k = 0;

public int[] GetPrime() {

int[] getPrime = new int[this.integer];

boolean isPrime = true;

for (int i = 2; i < this.integer; i++) {

for (int h = 2; h < i; h++) {

if (i % h == 0) {

isPrime = false;

break;

}

}

if (isPrime) {

getPrime[k] = i;

k++;

} else isPrime = true;

}

return reverse(getPrime);

}

public int[] reverse(int[] prime){

int tmp;

for(int i=0; i<prime.length/2; i++) {

tmp = prime[i];

prime[i] = prime[prime.length-1-i];

prime[prime.length-1-i] = tmp;

}

return prime;

}

}

10.7

=================================================================

import java.util.Date;

import java.util.Scanner;

public class dishizhang {

public static void main(String[] args) {

Account[] accounts = new Account[10];

for (int i = 0; i < 10; i++)

accounts[i] = new Account(1, 100);

System.out.print(“Enter an id:”);

Scanner input = new Scanner(System.in);

int id = input.nextInt();

while (id < 0 || id > 9) {

System.out.print(“The if is nonExistent,please input again:”);

id = input.nextInt();

}

mainMenu();

int choice = input.nextInt();

boolean judge = choice == 1 || choice == 2 || choice == 3;

while (judge) {

switch (choice) {

case 1:

System.out.println("The balance is "+accounts[id].getBalance());

break;

case 2:

System.out.print("Enter an amount to withdraw: ");

double withdraw = input.nextDouble();

accounts[id].withdraw(withdraw);

break;

case 3:

System.out.print(“Enter an amount to deposit:”);

double deposit=input.nextDouble();

accounts[id].deposit(deposit);

break;

}

mainMenu();

choice=input.nextInt();

judge = choice == 1 || choice == 2 || choice == 3;

}

dishizhang.main(args);

}

public static void mainMenu(){

System.out.println(“Main menu”);

System.out.println("1: check balance ");

System.out.println("2: withdraw ");

System.out.println("3: deposit ");

System.out.println("4: exit ");

System.out.print("Enter a choice: ");

}

}

class Account {

public Account() {

dateCreated = new Date();

}

public Account(int id,double balance){

this.id = id;

this.balance = balance;

dateCreated = new Date();

}

private int id;

总目录展示

该笔记共八个节点（由浅入深），分为三大模块。

高性能。 秒杀涉及大量的并发读和并发写，因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。

一致性。 秒杀中商品减库存的实现方式同样关键。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。因此，将用一个节点来专门讲解如何设计秒杀减库存方案。

高可用。 虽然介绍了很多极致的优化思路，但现实中总难免出现一些我们考虑不到的情况，所以要保证系统的高可用和正确性，还要设计一个PlanB来兜底，以便在最坏情况发生时仍然能够从容应对。笔记的最后，将带你思考可以从哪些环节来设计兜底方案。

---

篇幅有限，无法一个模块一个模块详细的展示（这些要点都收集在了这份《高并发秒杀顶级教程》里），麻烦各位转发一下（可以帮助更多的人看到哟！）

由于内容太多，这里只截取部分的内容。
alance){

this.id = id;

this.balance = balance;

dateCreated = new Date();

}

private int id;

总目录展示

该笔记共八个节点（由浅入深），分为三大模块。

高性能。 秒杀涉及大量的并发读和并发写，因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。

一致性。 秒杀中商品减库存的实现方式同样关键。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。因此，将用一个节点来专门讲解如何设计秒杀减库存方案。

高可用。 虽然介绍了很多极致的优化思路，但现实中总难免出现一些我们考虑不到的情况，所以要保证系统的高可用和正确性，还要设计一个PlanB来兜底，以便在最坏情况发生时仍然能够从容应对。笔记的最后，将带你思考可以从哪些环节来设计兜底方案。

---

篇幅有限，无法一个模块一个模块详细的展示（这些要点都收集在了这份《高并发秒杀顶级教程》里），麻烦各位转发一下（可以帮助更多的人看到哟！）

[外链图片转存中…(img-UtRkxMuj-1719275073261)]

[外链图片转存中…(img-Ns7GS4Jn-1719275073262)]

由于内容太多，这里只截取部分的内容。