文章介绍了服务器的工作原理、性能指标如响应时间和吞吐量，以及服务器的分类。同时，提供了一个简单的计算器程序示例，支持加减乘除和循环计算。还讨论了数组的概念，包括声明、创建和遍历，以及多维数组和冒泡排序算法。最后提到了在处理大量零值或相同值时，稀疏数组的效率优势。
服务器
### 服务器与计算机的主要区别
在这个过程中提供给服务的部分就是服务器
服务器包括：文件存储、数据库、服务接口
性能指标
-
RT（response time 响应时间）
-
Throuhgput（吞吐量）
-
TPS（Transactions Per Second 每秒传输的事务处理个数）
-
QPS（Querier Per Second 每秒查询率）
QPS 基本类似于TPS，不同的是：一个页面的一次访问，计入TPS；一次页面请求，可能产生多次对服务器的请求，对于这些请求，计入QPS
分类
1.按产品形态：
- 塔式
- 机架式
- 刀片式
2.按指令集：
- CISC（Complex Instruction Set Computing）
- RISC（Reduced Instruction Set Computing）
- EPIC（Explicitly Instruction Set Computing）
3.按处理器数量
- 单路服务器
- 双路服务器
- 四路服务器
- 八路服务器
作业
写一个计算器，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交换实现
* 思路：
* 写四个算法：加减乘除
* 利用循环+switch进行用户交互
* 传递需要操作的两个数
* 输出结果
package com.xiaobai.homework;
import java.util.Scanner;
public class Calc {
static double result = 0;
public static void main(String[] args) {
// 写一个计算器，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交换实现
/*写四个算法：加减乘除
利用循环+switch进行用户交互
传递需要操作的两个数
输出结果
*/
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("开始或结束运算：1.开始 2.结束");
int jud_num = scanner.nextInt();
if (jud_num == 1) {
System.out.println("请选择计算类型：1.加法 2.减法 3.乘法 4.除法");
int sele_num01 = scanner.nextInt();
switch (sele_num01) {
case 1:
System.out.println("请问是整数运算还是小数运算：1.整数 2.小数");
int sele_num02 = scanner.nextInt();
System.out.println("请输入进行计算的数的个数：");
int cal_num01 = scanner.nextInt();
if (sele_num02 == 1) {
int[] add_array01 = new int[cal_num01];
for (int i = 0; i < cal_num01; i++) {
System.out.println("请输入第" + (i + 1) + "个相加的数字：");
add_array01[i] = scanner.nextInt();
}
System.out.println("相加后的结果为：" + add(add_array01));
}else if (sele_num02 == 2) {
double[] add_array02 = new double[cal_num01];
for (int i = 0; i < cal_num01; i++) {
System.out.println("请输入第" + (i + 1) + "个相加的数字：");
add_array02[i] = scanner.nextDouble();
}
System.out.println("相加后的结果为：" + add(add_array02));
}
break;
case 2:
System.out.println("请问是整数运算还是小数运算：1.整数 2.小数");
int sele_num03 = scanner.nextInt();
System.out.println("请输入进行计算的数的个数：");
int cal_num02 = scanner.nextInt();
if (sele_num03 == 1) {
int[] sub_array01 = new int[cal_num02];
for (int i = 0; i < cal_num02; i++) {
System.out.println("请输入第" + (i + 1) + "个相减的数字：");
sub_array01[i] = scanner.nextInt();
}
System.out.println("相减后的结果为：" + sub(sub_array01));
} else if (sele_num03 == 2) {
double[] sub_array02 = new double[cal_num02];
for (int i = 0; i < cal_num02; i++) {
System.out.println("请输入第" + (i + 1) + "个相减的数字：");
sub_array02[i] = scanner.nextDouble();
}
System.out.println("相减后的结果为：" + sub(sub_array02));
}
break;
case 3:
System.out.println("请问是整数运算还是小数运算：1.整数 2.小数");
int sele_num04 = scanner.nextInt();
System.out.println("请输入进行计算的数的个数：");
int cal_num03 = scanner.nextInt();
if (sele_num04 == 1) {
int[] mult_array01 = new int[cal_num03];
for (int i = 0; i < cal_num03; i++) {
System.out.println("请输入第" + (i + 1) + "个相乘的数字：");
mult_array01[i] = scanner.nextInt();
}
System.out.println("相乘后的结果为：" + mult(mult_array01));
} else if (sele_num04 == 2) {
double[] mult_array02 = new double[cal_num03];
for (int i = 0; i < cal_num03; i++) {
System.out.println("请输入第" + (i + 1) + "个相乘的数字：");
mult_array02[i] = scanner.nextDouble();
}
System.out.println("相乘后的结果为：" + mult(mult_array02));
}
break;
case 4:
System.out.println("请问是整数运算还是小数运算：1.整数 2.小数");
int sele_num05 = scanner.nextInt();
System.out.println("请输入进行计算的数的个数：");
int cal_num04 = scanner.nextInt();
if (sele_num05 == 1) {
int[] div_array01 = new int[cal_num04];
for (int i = 0; i < cal_num04; i++) {
System.out.println("请输入第" + (i + 1) + "个相除的数字：");
div_array01[i] = scanner.nextInt();
}
System.out.println("相除后的结果为：" + div(div_array01));
} else if (sele_num05 == 2) {
double[] div_array02 = new double[cal_num04];
for (int i = 0; i < cal_num04; i++) {
System.out.println("请输入第" + (i + 1) + "个相除的数字：");
div_array02[i] = scanner.nextDouble();
}
System.out.println("相除后的结果为：" + div(div_array02));
}
break;
}
} else {
System.out.println("计算已结束");
break;
}
}
scanner.close();
}
public static double add(double... x) {
for (double element : x) {
result += element;
}
return result;
}
public static double add(int... x) {
for (int element : x) {
result += element;
}
return result;
}
public static double sub(double... x) {
result = x[0];
for (int i = 1; i < x.length; i++) {
result -= x[i];
}
return result;
}
public static double sub(int... x) {
result = x[0];
for (int i = 1; i < x.length; i++) {
result -= x[i];
}
return result;
}
public static double mult(double... x) {
result = 1.0;
for (double element : x) {
result *= element;
}
return result;
}
public static double mult(int... x) {
result = 1;
for (int element : x) {
result *= element;
}
return result;
}
public static double div(double... x) {
result = x[0];
for (int i = 1; i < x.length; i++) {
result /= x[i];
}
return result;
}
public static double div(int... x) {
result = x[0];
for (int i = 1; i < x.length; i++) {
result /= x[i];
}
return result;
}
}
数组
数组是相同类型数据的有序集合
### 数组的声明和创建
-
声明数组的方法
datatype[] arrayRefvar; //首选 datatype arrayRefvar[]; //效果相同，但非首选 -
java中使用new操作符来创建数组
datatype[] arrayRefvar = new datatype[arraySize]; -
数组的访问通过下标，计算数组长度.length
内存分析
三种初始化
-
静态初始化
int[] a ={1,2,3}; Man[] mans = {new Man(1,1),new Man(2,2)}; -
动态初始化
int[] a = new int[2]; a[0]=1; a[1]=2; -
默认初始化
数组是引用类型，它的元素相当于类的实力变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化
数组的四个基本特点
- 其长度是确定的，一旦被创建，大小不可被改变
- 元素必须是相同类型，不允许出现混合类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属于引用类型，数组也可以看成是对象，数组的每个元素相当于该对象的成员变量
- 数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
数组边界
下标的合法区间：[0，length-1],如果越界就会报错
ArrayIndexOutOfBoundsException：越界异常
小结
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合
- 数组也是对象，数组元素相当于对象的成员变量
- 数组长度是确定的，不可变的
数组的使用
- 普通用法 ArrayDemo03 for循环遍历
- For-Each循环 加强for循环 快捷方式
- 数组作方法入参
- 数组作返回值 ArrayDemo04 反转数组操作
多维数组
-
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每个元素都是一个一维数组
-
二维数组
int a[][] = new int[2][5]; // 2行5列的数组
-
二维数组的遍历操作：嵌套for循环
for (int i = 0; i < array.length; i++) { for (int j = 0; j <array[i].length ; j++) { System.out.print(array[i][j]+" "); } }
Arrays类
- 数组的工具类java.util.Arrays
- Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用“使用对象来调用（注意：是不用，不是不能）
- 具体以下常用功能：
- 给数组赋值：通过fill方法
- 对数组排序：通过sort方法，按升序
- 比较数组：通过equals方法比较数组中元素值是否相等
- 查找数组元素：通过binarSearch方法能对排序好的数组进行二分查找法操作，返回的是查找值的索引
冒泡排序
冒泡排序是最出名的排序算法之一，共有八大排序 ArrayDemo07 时间复杂度O(n^2)
稀疏数组
- 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
- 稀疏数组的处理方式：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
- 图左边为原始数组，右边为稀疏数组
扫一扫
1105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
