玉米迪迪

Java学习日记（一）

第一部分语法基础

- 第一章概述
- 1.1计算机组成部分
- 1.2人机交互方式
- 1.3计算机语言
- 1.4软件与软件开发
- 1.5java语言介绍
- 1.6Java开发环境搭建
- 1.7运行Java程序
- 1.8常见错误
- 1.9编程练习题
- 第二章基本数据与运算
- 2.1关键字
- 2.2标识符
- 2.3注释
- 2.4常量与进制
- 2.5变量
- 2.6数据类型
- 2.7运算符
- 2.8常见错误
- 2.9编程练习题
- 第三章流程控制语句
- 3.1if条件语句
- 3.2switch分支语句
- 3.3for循环
- 3.3while循环
- 第四章常用类
- 4.1 Math类
- 4.2 Scanner类
- 4.3 Random类
- 4.4 String类
- 4.5 Character类
- 第五章函数
- 5.2 函数的运行原理
- 5.3 函数重载
- 5.4 函数的递归
- 第六章数组
- 6.1 数组的概念及定义
- 数组的定义方式
- 6.2 常用数组操作
- 数组遍历问题
- 数组最值问题
- 数组扩容问题
- 选择排序算法
- 冒泡排序算法
- 插入排序算法
- 计数排序算法
- 基数排序算法
- 二分查找算法
- 可变长参数列表
- 6.3 二维数组
- 二维数组的定义

第一章概述

1.1计算机组成部分

 计算机主要分为两大类：硬件和软件。

硬件是可以看得到的一些物理部分，都是一些电子元件器件
软件是看不到的部分，它是一些列的命令，这些指令主要用于控制硬件来完成一些列特定的工作
常见的硬件：
1、CPU：Center Processing Unit中央处理器主要指令控制和数值计算功能（日常工作任务）
2、内存：临时性存储数据的存储设备RAM，当内存不通电的时候，这数据也就消失了
3、显卡GPU：Graphic Processing Unit 图形图像处理单元主要用于计算图形数据（图形图像任务）
4、存储设备：永久性存储设备ROM 任何数据都是以二进制的形式存储的机械硬盘、固态硬盘、U盘、光盘、移动硬盘。
5、输入输出设备

键盘：输入字符数据
鼠标：输入定位数据
显示器：输出图形图像数据
扬声器：输出声音数据
麦克风：输入声音数据
打印机：输出图形图像文本数据
扫描仪：输入图形图像文本数据
6、网络设备
输入：从互联网上下载数据
输出：从本地上传数据到互联网

1.2人机交互方式

我们如何与计算机打交道的
图形化界面操作方式：操作简单，表现直观，容易上手操作，步骤繁琐，占用空间大
命令行操作方式 CMD（Command win+R 输入cmd回车）窗口：操作复杂，命令较多，不容易上手，步骤简单，占用空间小，适合远程操作

常用dos命令
c: 进入C盘根目录
d: 进入D盘根目录
cd xxx 进入xxx目录
dir 查看当前目录下有什么文件和目录
cd / 进入到当前所在盘符的根目录
cd … 返回上一级目录
cls 清屏
exit 退出cmd窗口

1.3计算机语言

计算机本身就是有一系列物理硬件组成的，它们之间的沟通方式就是电信号，高低电压-二进制数据。
所以和计算机之间打交道，就得通过二进制来做，早期的编程语言/命令都是以二进制形式存在。
（1）机器语言
根据平台的不同其所表现的形式也不同，为了让计算机能够懂得人类的目的，人类必须以二进制的形式向计算机输入数据。计算机能懂，人不太懂，对初学者十分不友好的。
（2）汇编语言
通过一些单词也叫助记符，将一些常用的操作用单词表示，在程序中慢慢出现了人类的语言。比如计算2+3的结果，在汇编语言里是一下结果。这种代码计算机读不懂，还得将这些助记符包括数据转换成对应的二进制提交给计算机进行计算。转换的工具，称之为汇编器。汇编语言它的计算方式，还是依赖于计算机的计算方式的。想学好汇编语言，还得事先了解计算机的工作原理。
（3）高级编程语言
从20世纪50年代产生，第一个众所周知的高级编程语言：C语言->C++语言->Java语言->C#-Python高级编程语言完全由单词，符号和数字组成，并且书写流程也是符号人类流程。比如计算2+3如下代码所示，更容易让人类去理解。同样计算机不能够读懂这段代码，还得将代码进行转换二进制提交给计算机。转换的形式：编译，解释
（4）静态编译语言：C C++ Java
静态：在定义变量的时候有明确的数据类型的区分
编译：将源代码全部进行编译生成一个可执行的二进制文件计算机去执行这个二进
制文件来运行程序。（翻译一本英文书）
（5）动态解释语言：Python JS
动态：在定义变量的时候没有明确的数据类型的区分
解释：将源代码从头到尾读取一行编译一行运行一行（同声传译）

1.4软件与软件开发

（1）软件的定义
软件是指一系列按照特定顺序组织的计算机数据与指令的集合
举例：向西走50米然后左转向前走20米
输入三个点的坐标通过三边来计算一个三角形的面积？
说明：再用编程去解决一个问题的时候，先去获取该问题所需要的数据，然后再根据数据讨论计算的具体流程，最后再用编程语言去实现这个计算的流程
（2）软件的分类
两类：
系统软件：也称之为是操作系统，主要是用来控制和管理底层硬件的一套指令，操作系统为用户提供最基本的计算机功能。
应用软件：基于系统软件之上的，为用户带了特定领域服务的软件
（3）软件开发
软件开发的定义就是去编写上述软件，软件开发的流程是什么？

需求分析
编码实现
测试编码
上线运维
更新迭代
下线

（4）软件岗位

移动端软件研发 Anroid IOS - 物联网
Web前端研发 - 数据可视化工程师
PC端研发
后端研发

1.5java语言介绍

Java语言的前身Oak（橡树），1994年詹姆斯高斯林和他的团队开发出来的嵌入式编程语言。随着互联网的发展，紧随潮流编程互联网应用程序开发语言（面向对象），一直到2010年Sun公Oracle收购，Java就属于Oralce的子产品。
Oracle公司主要业务：

数据库 Oralce数据库随后也把民间产品MySQL也收购了
Linux服务器操作系统Solaris（redhat Ubuntu 深度 SUSE）
编程语言Java
Microso公司主要业务：
SQL Server
Windows/Windows Server
C++/C#
Java技术架构
JavaSE Java Standard Edition Java标准版：桌面型应用程序
JavaEE Java EnterpriseEdition Java企业版：服务器应用程序
JavaME Java Micro Edition Java微型版：嵌入式应用程序
Java最大的特点——跨平台
跨平台的意思就是说，一个软件可以在多个平台上运行，而不用更改软件的内容。
是因为JVM的功劳：JVM（Java Virtual Machine）Java虚拟机。
Java源代码文件后缀名为xxx.java 所编译出来的二进制文件后缀名为xxx.class
JVM主要负责将java语言的字节码文件转换为本地操作系统指令的一个工具软件。
所以，最终是字节码文件在跨平台！

1.6Java开发环境搭建

JRE与JDK
JRE（Java Runtime Environment）Java运行环境：如果我们的计算机仅仅想运行Java程序的话，装这个软件即可。JRE = JVM + 核心类库。
JDK（Java Development Kit）Java开发工具包：如果我们的计算机想要去开发一个Java程序的话，装这个软件即可。JDK = 开发工具 + JRE。
JDK的下载与安装

先登录注册Oracle
去Oralce官网下载JDK，最新JDK15，我们目前用JDK8 https://www.oracle.com
点击Products
点击SoWare下的Java
右上角DownloadJava
找到JavaSE8 点击JDK Download
下拉在下载列表中选择Windows X64
双击打开jdk安装程序
点击下一步
JDK不需要更改目录直接下一步
JRE不需要更改目录直接下一步
安装完成点击关闭即可
验证jdk是否安装成功
win+r 打开cmd 输入 java -version

java version "1.8.0_77"
Java(TM) SE Runtime Environment (build 1.8.0_77-b03)
Java HotSpot(TM) 64-Bit Server VM (build 25.77-b03, mixed mode)

说明安装成功！
jdk安装目录介绍
bin目录：binary放的都是开发工具
javac.exe：java编译工具
用法: javac
java.exe：java运行工具
用法: java [-options] class [args…]
(执行类)
或 java [-options] -jar jarfile [args…]
(执行 jar 文件)
db目录：放的是支持数据库开发的一些工具包
include目录：放的是一些链接底层的一些C头文件代码
jre目录：jdk自带的运行环境
lib目录：library 存放的是一些第三方Java库
javafx-src.zip：javafx图形化界面开发的源码包
src.zip：Java本身的源代码包
C:\Users\hmd>cd /
C:>cd “Program Files”
C:\Program Files>cd Java
C:\Program Files\Java>cd jdk1.8.0_77
C:\Program Files\Java\jdk1.8.0_77>cd bin
配置path环境变量

复制jdk中bin目录的绝对地址 C:\Program Files\Java\jdk1.8.0_77\bin
右键此电脑点击属性
点击高级系统设置
点击环境变量
系统变量中选择Path
右上角新建将地址复制进去即可
一路确定出去
重启cmd 再去尝试javavc java

1.7运行Java程序

VSCode代码编辑器 https://code.visualstudio.com/
汉化：左下角管理 Extension 搜索Chinese 选择Chinese中文简体汉化包点击绿色install 右下角提示重启重启即可
主题：管理颜色主题自选
编码：管理设置文本编辑器文件 Encoding 选择gbk结尾
字体：管理设置文本编辑器字体 font size
关联代码所在的文件夹：文件打开文件夹选择javaday01code
步骤一：新建Java源代码文件并写入类
点击新建文件按钮，输入Java源代码文件名称和后缀名，例如Sample01.java
在文件中写入如下代码：

public class Sample01 {
}

public class Sample01 中的 Sample01 是类名，而且在Java源代码中，可以存在多个类，但是
最多只能有一个public开头的类，并且该类的类名必须与文件名保持一致！！！
步骤二：编译该源代码文件
打开控制台窗口cmd，将目录切换到javaday01code目录下

C:\Users\hmd>cd Desktop
C:\Users\hmd\Desktop>cd javaday01cide

再输入 javac Sample01.java 对源代码文件进行编译

C:\Users\hmd\Desktop\javaday01code>javac Sample01.java

如果没有任何输出，则表明编译成功，并生成同名的字节码文件 Sample01.class
步骤三：运行该字节码文件
输入 java Sample01 即可

C:\Users\hmd\Desktop\javaday01code>java Sample01
错误: 在类 Sample01 中找不到 main 方法, 请将 main 方法定义为:
public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application

此时发现运行工具提示错误，对于任何一个程序而言，程序的运行都需要主函数，所以将主函数写
入其中。

public class Sample01 {
public static void main(String[] args) {
System.out.println("Happy New Year!");
	}
}

	再重新编译和运行

C:\Users\hmd\Desktop\javaday01code>javac Sample01.java
C:\Users\hmd\Desktop\javaday01code>java Sample01
Happy New Yaer!

1.8常见错误

语法错误
指在编译的过程中出现的一些错误，这种错误的原因主要由那些因素产生呢？
单词评写:main—main
遗漏分号:System.out.println(“Happy New Year!”)（缺少分号）
使用中文符号的问题
大括号不匹配：（缺少大括号）
遗漏关键字单词：Static等
运行错误
是指编译能够通过，但是在运行期间出现的问题
编译器只检查语法问题，但不检查算法是否运用正确，只要语法正确都能编译成功，而运行出来的结果可能与自己的需求不符合。
逻辑错误

代码的运行结果和自己认为的结果不一样！比如 / 整除只会保留整数部分，舍去小数部分。
遗漏括号
遗漏分号
遗漏引号
非法使用中文符号
单词拼写错误

1.9编程练习题

public class Demo01{
    public static void main(String[] args){
        System.out.print((9.5 * 4.5 - 2.5 * 3)/(45.5 - 3.5));
    }
}

public class Demo02{
    public static void main(String[] args){
        System.out.println(4 * (1.0 - 1.0 / 3 + 1.0 / 5 - 1.0 / 7 + 1.0 / 9 - 1.0 / 11));
        System.out.println(4 * (1.0 - 1.0 / 3 + 1.0 / 5 - 1.0 / 7 + 1.0 / 9 - 1.0 / 11 + 1.0 / 13));

    }
}

public class Demo03{
    public static void main(String[] args){
        double radius = 5.5;
        System.out.println("周长 = " + 2 * radius * 3.14 + "面积 = " + radius * radius * 3.14);
    }
}

public class Demo04{
    public static void main(String[] args){
        System.out.print(14/ 1.6 / (45 * 60 + 30) * 3600 + "英里/小时");
    }
}

public class Demo05{
    public static void main(String[] args){
        double hour = 1 + (40.0 * 60.0 + 35) / 3600;
        double km = 24 * 1.6;
        double speed = km / hour;
        System.out.println(speed + "公里/小时");
    }
}

public class Demo06{
    public static void main(String[] args){
        double a = 3.4;
        double b = 50.2;
        double c = 2.1;
        double d = 0;
        double e = 44.5;
        double f = 5.9;
        double x = (e * d - b * f) / (a * d - b * c);
        double y = (a * f - e * c) / (a * d - b * c);
        System.out.println("x = "+ x + "y = "+ y );
    }
}

第二章基本数据与运算

2.1关键字

关键字是指被高级编程语言赋予特殊含义的一些单词，关键字一般都是由小写字母组成。好比是汉语当中的一些专有名词：北京，天安门，兵马俑。不能乱用。

用于定义数据类型的关键字：byte short int long float double char boolean void class
interface
用于定义数据类型值的关键字：true false null
用于定义流程控制语句的关键字：if else switch case default while do for break
continue return
用于定义访问权限修饰符的关键字：public protected private
用于定义继承关系的关键字：extends implements
用于定义实例对象的关键字：new this super instanceof
用于定义函数类型的关键字：static final abstract synchronized
用于处理异常的关键字：try catch finally throw throws
用于包的关键字：package import
其他的一些修饰关键字：native assert volatile transient

2.2标识符

标识符指的是我们在程序中对变量、函数、类、接口、常量所定义的名称，也就是说这些名称是我们自定义的。
标识符必须满足以下组成规则：

标识符可以由数字、字母、下划线 _ 、美元符 $ 组成
标识符不能以数字开头，当然下划线和美元符其实是可以开头的，但不推荐
标识符不能是关键字
标识符也不能是Java内置类的名称
标识符可以为任意长度，但必须是一个连续的词
标识符严格区分大小写
标识符是为那些抽象的数据进行的自定义起名，为了方便程序的阅读和理解，起名尽量要有含义，不要通篇都是a b c d e f g…。在一些特殊的情况下（循环里特殊数学符号），可以使用i j km n 之类的。

标识符命名的规范：

大驼峰式：主要针对类名，接口名。所有单词的首字母大写
小驼峰是：主要针对于变量名，函数名。除了第一个单词之外，其他单词首字母大写
常量规范：所有单词字母大写，单词与单词之间用下划线分隔
包名规范：所有单词字母小写，单词与单词之间用句号 . 分隔
myAge 变量名
getMax() 函数名
MyMoney 类名接口名
MAX_VALUE 常量名
com.oupeng.java 包名

2.3注释

注释是用于注解和说明程序的一些程序中的内置文本信息的，但这些内置文本不属于代码的范畴。
所以在对含有注释的源代码进行编译时，所生成的字节码中不含有注释。注释给人看的！
注释主要有三种：

单行注释 //注释内容直到换行为止
多行注释 /* 注释内容内部可以进行换行 */
文档注释 /** 注释内容内部可以进行换行 */ ：文档注释可以被编译器识别，并生成相应的程序说明书。对某一个类进行文档生成时，该类必须是public型。
额外的，注释除了有解释说明程序的功能之外，还可以用来调试程序。多行注释中，不能再出现多行注释。在写代码时，一定要先写注释，并且，注释最好详细一些。

2.4常量与进制

常量就是指在程序中直接出现的一些数据，也叫字面量
常量都有哪些：

整数常量：十进制D 二进制B 八进制O 十六进制H
小数常量: 科学计数法 1.23e3=1230
字符常量：由一个字母、数字、符号被单引号( ‘’ )标识的数据。可以打印单个汉字、字母、打印符号需要加一个\进行转义，\n换行,\t缩进
字符串常量：由若干个字母、数字、符号被双引号( “” )标识的数据。""，里面不写内容也可以打印，叫做空串。null真空。
布尔类型常量：true false表示真假
null常量

负数的二进制
-29的二进制将正数部分的二进制先取反再加1 即为负数的二进制
00011101 =>取反 11100010 =>加1 11100011

2.5变量

指的是变化的量。
变量的本质就是在内存中程序所处的进程中的一个临时存储区域。

该区域的存储值有限制的
该区域值的变化必须是同类型的或向下兼容的
该区域有其自身的物理内存地址-指针
该区域中存储值的限制和数据的变化类型由数据类型来决定
该区域中其空间的分配和空间的物理内存地址由计算机底层来决定
为了便于理解数据类型，我们对指针进行一个回顾

#include
void main(){
    //指针： 数据类型 * 指针名 ---变量名 int * p
    int *p;
    int a = 3; //创建了一个一级指针
    p = &a;// 
    //*指针运算符：（间接寻址符）： 与&互为逆运算，作用就是通过操作对象的地址，获取存储的内容
    //&取地址运算符：用来操作对象的地址。
    int ** q;//创建了一里指向个二级指针  一个二级指针只能存放一级指针的内容
    q =  &p;//不能写&a

    printf("%d\n",p);//a的地址
    printf("%d\n",&a);//a的地址
    printf("%d\n",q);//p的地址
    printf("%d\n",*q);//a的地址
    printf("%d\n",&*q);//p的地址
    printf("%d\n",&*&*&*q);//p的地址

2.6数据类型

在Java当中，数据类型主要分为两大类：
1、基本数据类型：在变量的空间中存储数据
整型

byte 1字节 2⁸ 256 -128~127 -2⁷ ~ 2⁷ - 1
short 2字节 2¹⁶ 65536 -32768-32767
int 4字节 max = 2³¹-1
long 8字节

浮点型

float 4字节
double 8字节

字符型

char 2字节

布尔型

boolean 不确定
在常量中，整型常量默认int类型，小数常量默认是double类型。
布尔类型，如果是单一变量的话，在JVM中true被认为是1 false被认为是0 所以是4字节存。
如果是布尔类型数组的话，在JVM中true和false被认为是byte类型 1字节。

2、引用数据类型：数据是在堆内存中存储，变量仅仅存放的是数据在堆内存中的地址

字符串
数组
对象
在Java中，但凡存储在堆内存中的数据，统称为对象

2.7运算符

算术运算符

算术运算符	含义	备注
+	加法	1+2=3如+左右有字符串，则加号为连接符
-	减法
*	乘法
/	除法	3/2=1 3.0/2 =1.5 除号左边为整型，则整除；为浮点型，则为小数
%	取余	9%4=1
a++	前置自增加法	a自身加一，使用原来的值
++a	后置自增	a自身加一，使用加之后的值
a–	后置自减	a自身减一，使用原来的值
–a	前置自减	减a自身减一，使用加之后的值

赋值运算符

搡作符	名称	示例	等价于
+=	加法賦值操作符	i += 8	i = i + 8
-=	减法賦值搡作符	i -= 8	i = i - 8
*=	乘法賦值操作符	i *= 8	i = i * 8
/=	除法賦值搡作符	i /= 8	i = i / 8
%=	求余賦值操作符	i %= 8	i = i % 8

比较运算符
运算的结果为布尔类型

大于
< 小于
= 大于等于
<= 小于等于
!= 不等于
逻辑运算符
& 单与
| 单或
^ 异或
! 非
&& 双与
|| 双或

public class Sample {
public static void main(String[] args) {
int x = 0;
int y = 0;
System.out.println(x++ > 0 & y++ > 0);
System.out.println(x);
System.out.println(y);
x = 0;
y = 0;
System.out.println(x++ > 0 && y++ > 0);
System.out.println(x);
System.out.println(y);
//&& 如果左边为假 则右边不用执行
//|| 如果左边为真 则右边不用执行
//相同为假 不同为真
System.out.println(true ^ true);
System.out.println(true ^ false);
System.out.println(false ^ false);
System.out.println(false ^ true);
}
}

位运算符

右移
<< 左移
& 位与
| 位或
^ 位异或

public class Sample {
public static void main(String[] args) {
int x = 7;
int y = 12;
System.out.println(x & y);
/*
0111
1100 &
0100 4
*/
System.out.println(x | y);
/*
0111
1100 |
1111 15
*/
System.out.println(x ^ y);
/*
0111
1100 ^
1011 11
*/
System.out.println(x << 3);
/*
0111
0111000
x * 2^3
*/
System.out.println(56 >> 2);
/*
111000
1110
56 / 2^2
*/
}
}

三目运算符
数据类型变量名 = 布尔表达式?值1:值2;
int number = 10 % 2 == 0? 10 : 2;

补充问题：变量交换问题

int a = 3;
int b = 7；
//方法一：
int c = a;
a = b;
b = c;
System.out.println(a);
System.out.println(b);
//方法二：
a = a + b;
b = a - b;
a = a - b;
System.out.println(a);
System.out.println(b);
//方法三：
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println(a);
System.out.println(b);

2.8常见错误

未声明变量，未初始化变量而使用变量
整型溢出问题
取整错误
（1）一个是小数的问题，小数主要去的是近似值想要得到一个0.5这个值的话有可能会得到0.4999999
（2）一个是整数的问题，1/3 = 0.3333 * 3 = 0.99999 数学上1
超出预期的除法问题
（1）/左右两边是整数，结果为整数，如果出现小数则结果为小数
额外冗余的输入对象

import java.util.Scanner;
public class Sample {
public static void main(String[] args) {
Scanner scanner1 = new Scanner(System.in);
System.out.print("请输入整数：");
int num1 = scanner1.nextInt();
//下面scanner2对象就是一个多余的
Scanner scanner2 = new Scanner(System.in);
System.out.print("请输入小数：");
double num2 = scanner2.nextDouble();
/*
Sample.java:3: 错误: 找不到符号
Scanner scanner = new Scanner(System.in);
^
符号: 类 Scanner
位置: 类 Sample
*/
}
}

2.9编程练习题

public class Demo07 {
/*
数据：总毫秒数 总秒数 总分钟数 总小时数
当前小时 当前分钟 当前秒
*/
    public static void main(String[] args) {
//1.获取总毫秒数
        long millis = System.currentTimeMillis();
//2.计算总秒数
        long seconds = millis / 1000;
//3.计算总分钟数
        long minutes = seconds / 60;
//4.计算总小时数
        long hours = minutes / 60;
//5.计算当前小时数
        long currentHours = hours % 24;
//6.计算当前分钟数
        long currenrMinutes = minutes % 60;
//7.计算当前秒数
        long currentSeconds = seconds % 60;
        System.out.println(currentHours + ":" + currenrMinutes + ":" +currentSeconds);
    }
}

import java.util.Scanner;
public class Demo08{
    public static void main(String[] args){
    Scanner input = new Scanner(System.in);
    System.out.println("请输入总钱数：");
    double money = input.nextDouble();
    //讲总钱数转换成一美元
    money = money * 100;
    int dollar =  (int) money / 100;
    money = money % 100;
    //转换成quarter
    int quarter = (int) money / 25;
    money = money % 25;
    //转换成1角
    int  dime = (int) money / 10;
    money = money % 10;
    //转换成5分
    int nickel = (int) money / 5;
    money = money % 5;
    int penny = (int) money;

    System.out.print(dollar + "dollar " + quarter + "quarter " + dime + "dime " + nickel + "nickel " + penny +"penny"  );

    }
}

import java.util.Scanner;
public class Demo09 {
/*
数据：华氏温度 摄氏温度
*/
    public static void main(String[] args) {
//1.提示用户输入摄氏温度
        Scanner input = new Scanner(System.in);
System.out.print("Enter a degree in Celsius:");
        double cel = input.nextDouble();
//2.利用已知公式计算华氏温度
        double fah = cel * 9 / 5 + 32;
//3.输出计算结果
        System.out.println(cel + " Celsius is " + fah + " Fahrenheit");
    }
}

import java.util.Scanner;
public class Demo10{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("Enter the radius and length of cylinder:");
        double radius = input.nextDouble();
        double height = input.nextDouble();
        double p = 3.14;
        double area = radius * radius * p;
        double volume = area * height;
        System.out.println("The area is" + area + "The volume is" + volume);
    }
}

import java.util.Scanner;
public class Demo11 {
/*
数据：输入的0~1000的数字
个位a 十位b 百位c
*/
    public static void main(String[] args) {
        //1.提示用户输入一个数字
        Scanner input = new Scanner(System.in);
        System.out.print("Enter a number:");
        int number = input.nextInt();
        //2.分别计算a b c       
        int a = number % 10;
        number /= 10;
        int b = number % 10;
        number /= 10;
        int c = number % 10;
        int sum = a + b + c;
        //3.输出结果
        System.out.println("The sum of digits is " + sum);
    }
}

import java.util.Scanner;

public class Demo12 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);	
		long totalMilliseconds = System.currentTimeMillis();
		long totalSeconds = totalMilliseconds / 1000;
		long currentSecond = totalSeconds % 60;
		long totalMinutes = totalSeconds / 60;
		long currentMinute = totalMinutes % 60;
		long totalHours = currentMinute / 60;
		long currentHour = totalHours % 24;	
		System.out.print("Enter the time zone offset to GMT:");
		byte utc = input.nextByte();
		System.out.println("Current time is " + (currentHour + utc) + ":"
				+ currentMinute + ":" + currentSecond + "GMT");
	}
}

import java.util.Scanner;
public class Demo13{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.print("Enter the amount of water in kilograms:");
        double kilograms = input.nextDouble();
        System.out.print("Enter the initial temperature:");
        double InitalT = input.nextDouble();
        System.out.print("Enter the final temperature:");
        double FinalT = input.nextDouble();
        double energy = kilograms * (FinalT - InitalT) * 4184;
        System.out.println("The energy needed is "  + energy);
    }
}

import java.util.Scanner;
public class Demo14{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.print("Enter the monthly saving amount:");
        double money = input.nextDouble();
        double totalmoney = 0;
        double rate = 1.00417;
        int month = 1;
        for(month = 1; month <= 12; month++ ){ 
            totalmoney = (totalmoney +money) * rate;
            System.out.println("The month is" + month + ",The account value is" + totalmoney);
        }
    }
}

import java.util.Scanner;
public class Demo15 {
/*
数据：两个点坐标 x1 y1 x2 y2 距离
*/
    public static void main(String[] args) {
        //1.提示用户输入两个点的坐标
        Scanner input = new Scanner(System.in);
        System.out.print("Enter x1 and y1:");
        double x1 = input.nextDouble();
        double y1 = input.nextDouble();
        System.out.print("Enter x2 and y2:");
        double x2 = input.nextDouble();
        double y2 = input.nextDouble();
        //2.计算两点间距离
        double distance = Math.sqrt(Math.pow(x2 - x1 , 2) + Math.pow(y2 - y1 , 2));
        //3.输出结果
        System.out.println("The distance between the two points is " + distance);
    }
}

import java.util.Scanner;
public class Demo16{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.print("Enter three points for a tringle:");
        double x1 = input.nextDouble();
        double y1 = input.nextDouble();
        double x2 = input.nextDouble();
        double y2 = input.nextDouble();
        double x3 = input.nextDouble();
        double y3 = input.nextDouble();
        double d1 = Math.sqrt(Math.pow(x1 - x2,2) + Math.pow(y1 - y2,2));
        double d2 = Math.sqrt(Math.pow(x2 - x3,2) + Math.pow(y2 - y3,2));
        double d3 = Math.sqrt(Math.pow(x3 - x1,2) + Math.pow(y3 - y1,2));
        double s = (d1 + d2 + d3) / 2;
        double area = Math.sqrt(s * (s - d1) * (s - d2) * (s - d3));
        System.out.print("The area of the triangle is" + area);

    }
}

第三章流程控制语句

3.1if条件语句

单分支语句

...CodeA
if（布尔表达式）{
	语句组；
	}
...CodeB

双分支if-else语句

...CodeA
if（布尔表达式）{
	语句组A；
}else{
	语句组B;
	}
...CodeB

多分支if-else-if语句

...CodeA
if（布尔表达式1）{
	语句组A;
}else if(布尔表达式2){
	语句组B;
}else if(布尔表达式){
	语句组C;
}else{
	语句组D;
}
...CodeB

3.2switch分支语句

与if分支语句一样，都是对条件的判断。switch一般用在条件较多的情况下，但是有一个重要的细节及时，if语言可以对区间值或固定值进行判断，switch只能对固定值进行判断。

switch (变量) {
case 值1: //if (变量==值1) {语句组A;}
语句组A;
break;
case 值2:
语句组B;
break;
...
case 值n: //if (变量==值n) {语句组N;}
语句组N;
default: // else {语句组N+1;}
语句组N+1;
break;
}

switch的一些小细节

switch所传入的变量，char,byte,short,int,String或者枚举型,java SE7开始，case标签还可以是字符串字面量。
值1，值2，一直到值n，这几个值必须是同一个数据类型
当变量匹配的相关casee的值的时候，执行case中的语句，直到遇到break结束；如果该case语句中没有break，则继续向下执行，直到遇到另外一个break结束。

public class Sample {
	public static void main(String[] args) {
		int a = 3;
		switch (a) {
			case 1:
				System.out.println("case 1");
				break;
			case 2:
				System.out.println("case 2");
				break;
			case 3:
				System.out.println("case 3");
			case 4:
				System.out.println("case 4");
			case 5:
				System.out.println("case 5");
				break;
			default :
				System.out.println("default");
				break;
		}
	}
}

3.3for循环

循环主要解决具有规律性且具有在重复性的代码问题，避免代码冗余。
循环四要素

循环的初始化：循环的第一次执行从哪里开始
循环的继续条件：循环从当前轮是否先后执行一轮
循环体：需要被循环执行的部分
循环的步长、周期：当前循环到下一轮循环之间的变化

我们常见的循环问题可以分为两大类：

已知循环次数的
未知循环次数但是已知循环结束条件一般用while语句做

for(1循环的初始化;2循环的继续条件;4循环的步长）{
	3循环体
	}

for循环演示

import java.util.Scanner;
public class Sample {
	public static void main(String[] args) {
	/*
	*****
	*/
		for (int i = 1; i <= 5; i++) {
			System.out.print("*");
		}
		System.out.println();
		System.out.println("=============================");
		/*
		*****
		*****
		*****
		*****
		*/
		for (int j = 1; j <= 4; j++) {
			for (int i = 1; i <= 5; i++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("=============================");
		/*
		*
		**
		***
		****
		*****
		******
		*******
		*/
		for (int line = 1; line <= 7; line++) {
			for (int i = 1; i <= line; i++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("=============================");
		/*
		******
		*****
		****
		***
		**
		*
		*/
		for (int line = 6; line >= 1; line--) {
			for (int i = 1; i <= line; i++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("=============================");
/* 					i 		j
		* 			1 		1
		** 			2 		1 2
		*** 		3		1 2 3
		**** 		4		1 2 3 4
		*****		5 		1 2 3 4 5
		****** 		6 		1 2 3 4 5 6 	j <= i
		***** 		7 		1 2 3 4 5
		****		8 		1 2 3 4
		*** 		9 		1 2 3
		** 			10 		1 2
		* 			11 		1 j <= 12 - i
		j <= i && j <= 12 - i
*/
		for (int i = 1; i <= 11; i++) {
			for (int j = 1; j <= i && j <= 12 - i; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("=============================");
/* 					i 		|i - 6|
			* 		1		-5
		   ** 		2 		-4
		  *** 		3 		-3
		 **** 		4 		-2
		***** 		5 		-1
	   ****** 		6 		 0
		***** 		7 		 1
		 **** 		8 		 2
		  *** 		9 		 3
		   ** 		10 		 4
			* 		11 		 5
*/
		for (int i = 1; i <= 11; i++) {
			for (int k = 1; k <= Math.abs(i - 6); k++) {
				System.out.print(" ");
			}
			for (int j = 1; j <= i && j <= 12 - i; j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
		System.out.println("=============================");
/* 					j
			* 		     1
		   * * 		    1 2
		  *   * 	   1 2 3
	     *     * 	  1 2 3 4
        *       * 	 1 2 3 4 5
       *         * 	1 2 3 4 5 6
		*       *	 1 2 3 4 5
		 *     *      1 2 3 4
          *   * 	   1 2 3
           * *		    1 2
            * 		     1
		j == 1 j == i j + i == 12
*/
		for (int i = 1; i <= 11; i++) {
			for (int k = 1; k <= Math.abs(i - 6); k++) {
				System.out.print(" ");
			}
			for (int j = 1; j <= i && j <= 12 - i; j++) {
				if (j == 1 || j == i || j + i == 12) {
					System.out.print("* ");
				} else {
					System.out.print(" ");
				}
			}
			System.out.println();
		}
	}
}

3.3while循环

while循环主要用于解决循环次数未知，但循环结束条件已知的情况。
while其实和for循环是可以相互转换的，是因为都逃不开循环四要素。

for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
可以转换为while循环
int i = 1;
while (i <= 5) {
System.out.println(i);
i++;
}

while的语法格式：

1.循环的初始化
while (2.循环继续条件) {
3.循环体
4.循环的步长、周期
}

3.5do …while
do…while语法格式

do
{
循环语句（循环体）
}

do…while循环与while循环的区别
do…while 先执行循环条件再执行判断
while 先执行判断是否需要执行循环
3.6continue和break
break在循环语句中叫做终止语句，终止的是break最近的一层循环。
continue在循环语句中叫做跳过语句，跳过本次循环开启下一轮循环。

import java.util.Scanner;
public class Sample {
	public static void main(String[] args) {
		for (int i = 1; i <= 5; i++) {
			if (i == 3) {
				break;
			} else {
				System.out.println(i);
			}
		}
		//结果 1 2
		for (int i = 1; i <= 5; i++) {
			if (i == 3) {
				continue;
			} else {
				System.out.println(i);
			}
		}
		//结果 1 2 4 5
	}
}

第四章常用类

4.1 Math类

Math类是用于数学计算的一个工具类。在程序中使用的时候,可以用Math.函数名（）来调用，也可以手动导入import static java lang.Math.*。
对于工具类而言，里面的大部分成员都是静态的static
自带常量

static double E：自然对数
static double PI：圆周率

取整方法

static double ceil(double a)：向上取整
static double floor(double a)：向下取整
static long round(double a)：四舍五入

三角函数

static double sin(double a)：正弦函数参数是弧度值
static double cos(double a)：余弦函数
static double tan(double a)：正切函数
static double toDegrees(double a)：将弧度转角度
static double toRadians(double angles)：将角度转弧度
static double asin(double a)：反正弦函数
static double acos(double a)：反余弦函数
static double atan(double a)：反正切函数

指数函数

static double pow(double a, double b)：求a的b次幂
static double sqrt(double a)：求a的平方根
static double cbrt(double a)：求a的立方根

其他方法

static double abs(double a)：求a的绝对值
static double hypot(double deltX, double deltY)：返回两点间距离
static double max(a,b)：返回a和b之间的最大值
static double min(a,b)：返回a和b之间的最小值
static double random()：返回[0,1）之间的随机小数

4.2 Scanner类

主要用于负责数据输入的类，底层是和IO流相关。

String next()：获取直到遇到空格为止的一个字符串
String nextLine()：获取直到遇到回车为止的一个字符串
int nextInt()：获取下一个整数 byte short long
double nextDouble()
boolean nextBoolean()
float nextFloat()

import java.util.Scanner;
public class Sample {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("输入一句话：");
		String line = input.nextLine();
		System.out.println(line);
		System.out.print("输入三个单词：");
		String word1 = input.next();
		String word2 = input.next();
		String word3 = input.next();
		System.out.println(word1);
		System.out.println(word2);
		System.out.println(word3);
	}
}

4.3 Random类

主要用于产生随机数

boolean nextBoolean()：随机产生布尔类型值
double nextDouble()：随机生成0.0~1.0之间的小数
double nextInt()：随机生成一个整数0~2³²的整数
double nextInt(n)：随机生成一个整数[0,n)的整数

import java.util.Random;
public class Sample {
	public static void main(String[] args) {
		Random random = new Random();
		for (int i = 1; i <= 10; i++) {
			System.out.print(random.nextBoolean() + " ");
		}
		System.out.println();
		for (int i = 1; i <= 10; i++) {
			System.out.print(random.nextInt(2) + " ");
		}
		System.out.println();
		for (int i = 1; i <= 10; i++) {
			System.out.print(random.nextInt() + " ");
		}
		System.out.println();
	}
}

4.4 String类

String是一个类，它描述的是字符串。在Java代码当中，所有字符串常量（字符串字面量）都是String类的一个实例对象。并且，字符串一旦创建，则不可修改！不可修改其长度，不可修改其内容。所以将来对字符串内容的改变，不能在原地改，只能重新创建一个字符串。

public class Sample {
	public static void main(String[] args) {
		String s1 = "abc";
		String s2 = "ab" + "dc";
		//上述代码一共有几个字符串？
		//四个"abc" "ab" "dc" "abdc"
	}
}

获取相关

char charAt(int index)：获取指定角标index处的字符
int indexOf(int ch)：获取指定字符(编码)在字符串中第一次（从左到右）出现的地方返回的是角标。如果是-1 表示不存在
int lastIndexOf(int ch)：获取指定字符(编码)在字符串中第一次（从右到做）出现的地方返回的是角标
int indexOf(String str)：获取指定字符串在本字符串中第一次（从左到右）出现的地方返回的是角标
int lastIndexOf(String str)：获取指定字符串在本字符串中第一次（从右到左）出现的地方返回的是角标
int length()：获取字符串的长度（字符的个数）
String[] split(String regex)：将字符串按照regex的定义进行切割（regex指的是正则表达式）
String substring(int beginIndex)：截取一段子字符串，从beginIndex开始到结尾
String substring(int beginIndex, int endIndex)：截取一段子字符串，从beginIndex开始到endIndex(不包含)

判断相关

int compareTo(String anotherString)：按照字典顺序比较两个字符串的大小
boolean contains(String another)：判断当前字符串中是否包含指定字符串another
boolean equals(String another)：比较当前字符串与指定字符串的内容是否相同
boolean isEmpty()：判断当前字符串是否为空，length() == 0
boolean startsWith(String prefix)：判断该字符串是否以prefix开头
boolean endsWith(String suix)：判断该字符串是否已suix结尾

修改相关

String toLowerCase()：将字符串中所有的英文字母全部变为小写
String toUpperCase()：将字符串中所有的英文字母全部变为大写
String trim()：将字符串中两端的多余空格进行删除
String replace(char oldCh,char newCh)：将字符串中oldCh字符替换成newCh字符

import java.util.Random;
public class Sample {
	public static void main(String[] args) {
		String str = "banana orange apple watermelon";
		System.out.println(str.charAt(1)); //'a'
		System.out.println(str.indexOf('o')); //7
		System.out.println(str.lastIndexOf(97));//21
		System.out.println(str.length());
		System.out.println(str.substring(6));
		System.out.println(str.substring(9,13));
		String[] arr = str.split(" ");
		System.out.println(arr[2]);
		String s1 = "abc";
		String s2 = "abe";
		System.out.println(s1.compareTo(s2));
		//结果<0 s1在s2之前 ==0 s1和s2一样 >0 s1在s2之后
		System.out.println("hehe".compareTo("hehe"));
		System.out.println("abcbc".contains("bcb"));
		System.out.println("lala".equals("lala"));
		String s3 = "大桥未久.avi";
		System.out.println(s3.endsWith(".avi"));
		System.out.println(s3.startsWith("大桥未久"));
		String s4 = "Happy Boy Happy Girl";
		System.out.println(s4.toLowerCase());
		System.out.println(s4.toUpperCase());
		System.out.println(s4);
		System.out.println(" 123123 321321 ".trim());
		String s5 = "旺财是只狗，旺财咋叫？旺财来叫一个~";
		System.out.println(s5.replace('狗','猫'));
		System.out.println(s5.replace("旺财","小强"));
	}
}

如何删除字符串中左右两端出现的空格，不用trim

public class Sample {
	public static void main(String[] args) {
		String str = " 123123123 12123 ";
	//去空格后"123123123 12123"
		int l = 0;
		int r = str.length() - 1;
		while (str.charAt(l) == ' ') {
			l++;
		}
		while (str.charAt(r) == ' ') {
		r--;
		}
		System.out.println("[" + str.substring(l,r + 1) + "]");
	}
}

在字符串"abcbcbcbcbcbc"中统计"bcb"出现的次数

public class Sample {
	public static void main(String[] args) {
		//最好的算法KMP算法
		String s1 = "abcbcbcbcbcbc";
		String s2 = "bcb";
		//贪心算法 5个
		int count = 0;
		for (int i = 0; i < s1.length() - s2.length() + 1; i++) {
			if (s1.charAt(i) == s2.charAt(0)) {
				if (s2.equals(s1.substring(i,i + s2.length()))) {
					count++;
				}
			}
		}
		System.out.println(count);
		//非贪心算法 3个
		/*
		String temp = s1;
		int count = 0;
		while (true) {
			int index = temp.indexOf(s2);
			if (index == -1) {
				break;
			}
			count++;
			temp = temp.substring(index + s2.length());
		}
		System.out.println(count);
		*/
	}
}

查找两个字符串中最长的公共子串

public class Sample {
	public static void main(String[] args) {
		String s1 = "c is a program but is diffcult";
		String s2 = "Java is a program but is slow";
		for (int len = s2.length(); len > 0; len--) {
			for (int l = 0,r = len - 1; r < s2.length(); l++,r++) {
				String temp = s2.substring(l,r + 1);
				if (s1.contains(temp)) {
					System.out.println(temp);
					return;//直接结束程序
				}
			}
		}
	}
}

4.5 Character类

Character它是char基本数据类型的包装类，有这么几个静态方法我可目前可以使用到的

static boolean isDigit(char ch)：判断字符是否是数字
static boolean isLetter(char ch)：判断字符是否是字母
static boolean isLetterOrDigit(char ch)：判断字符是否是数字或字母
static boolean isLowerCase(char ch)：判断是否是小写字母
static boolean isUpperCase(char ch)：判断是否是大写字母
static boolean isSpaceChar(char ch)：判断是否空白字母（空格制表符回车）

将十六进制数字转为十进制

import java.util.Scanner;
public class Sample {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("请输入一个十六进制的数字：");
		//0~9 A~F
		String hex = input.nextLine().toUpperCase();
		if (hex.length() == 0) {
			System.out.println("没有任何输入！");
			return;//程序直接结束
		}
		for (int i = 0; i < hex.length(); i++) {
			char ch = hex.charAt(i);
			if (Character.isDigit(ch) || Character.isLetter(ch)) {
				if (Character.isLetter(ch) && (ch < 'A' || ch > 'F')) {
					System.out.println("非法字符" + ch);
					return;
				}
			} else {
				System.out.println("非法字符" + ch);
				return;
			}
		}
		int sum = 0;
		for (int i = hex.length() - 1; i >= 0; i--) {
			char ch = hex.charAt(i);
			if (Character.isDigit(ch)) {
			//'1' ? 1
				sum = sum + (int)Math.pow(16 , hex.length() - i - 1) * (ch - 48);
			} else {
		//'A' - 65 + 10 -> 10
				sum = sum + (int)Math.pow(16 , hex.length() - i - 1) * (ch - 55);
			}
		}
		System.out.println(sum);
	}
}

第五章函数

什么是函数
函数的定义就是指一段具有独立功能的代码，减少代码冗余，提高程序的利用率和效率。
我们应该如何去定义函数呢？

需要一个封闭的空间，将这段独立性的代码进行封装，用一对大括号
需要对每一个封闭的空间进行命名，函数名
函数所需要的一些原始数据
函数所产生的一些结果数据

函数的语法格式

修饰符 函数类型 返回值类型 函数名(数据类型 数据1,数据类型 数据2,...) {
独立功能的代码片段;
return 函数的计算结果;
}

修饰符：指的是函数的访问权限，public private 默认 protected
函数类型：函数的分类，本地函数native，静态函数static，同步函数 synchronized
返回值类型：指的就是函数计算结果的数据类型如果函数没有返回值则为void
函数名：就是函数的名称
参数列表：指的是外界向函数传入的数据（实际参数），由这些参数变量进行接收（形式参数）
函数体：具有独立功能的代码片段；
return：仅仅表示函数结束！如果函数有返回值，则return后跟返回值；如果没有返回值，则return可以不写，但是是存在的（隐藏的在最后一行）

根据形参和返回值来看，函数有如下几个分类

有参数有返回值
有参数没返回值
没参数有返回值
没参数没返回值

总结定义函数时需要考虑的有哪些？

函数的运行有哪些未知的参数？
函数的运行结果有是什么？
明确参数和结果明确内容和返回
函数到底要干什么？尽量将独立功能且重复性较高的代码片段提取出来

5.2 函数的运行原理

函数的运行是基于栈运行的
栈：是一种先进后出的容器，我们这里面所说的栈是指JVM中的栈内存空间。
每一个函数，叫做栈帧，栈帧中所包含的内容有函数的定义，参数列表，函数的执行内容代码。
每一个函数要运行，就相当于这个栈帧进入到栈内存中-入栈。
如果一个函数即将结束，将这个栈帧从栈顶移出-出栈。
如果栈内存中有多个栈帧，运行的是最上面的栈帧，底下的栈帧暂停运行，直到该栈帧为栈顶元素。
比如：主函数先进栈，开始逐行运行，如果执行到第n行，调用另外一个函数A，则主函数在第n行暂停运行，将另一个函数A的栈帧入栈，再继续逐行运行，直到函数A的内容执行完毕，函数A出栈，主函数接着从第n行继续向下执行。以此类推。

5.3 函数重载

同一个类中可以出现多个同名函数，这个现象就叫做函数的重载（overload）
如何来区分同名函数是否是重载关系呢？前提必须是同名，和返回值类型无关（返回值类型只和函数的计算功能相关），和权限也没有关系，和形式参数的名称也无关！只和形式参数的数据类型有关（数量，排列组合）

public static void show(int a ,float b ,char c){}

下列哪些是该函数的重载：

int show(int x, float y, char z) ：不算重载数据类型都是int float char
void show(float b,int a,char c)：算重载，顺序不一样float int char
void show(int a,int b,int c)：算重载，顺序不一样int int int
double show()：算重载，参数不一样

寻找重载函数的流程：

看是否有确切的参数定义匹配，int int 找 int int
看是否有可兼容的参数定义匹配，int int找double double或int double或double int
如果可兼容的参数定义匹配较多，会报引用确定报错引用不明确

5.4 函数的递归

函数的递归就是指函数自身调用自身。

人用迭代，神用递归

但凡迭代能够解决的问题，递归都可以解决；递归能够解决的问题，迭代就不一定了
相对而言，从内存的角度而言，函数如果过多的自我调用，势必会对内存不友好，占用过多
通常来讲，同样的问题用递归写要比用迭代写代码量较少

写递归时，一定要先确定递归结束条件-递归边界
什么情况下可以使用递归？迭代的，数学归纳法的问题

第六章数组

6.1 数组的概念及定义

数组主要用于解决大量数据计算与存储的问题
比如：输入100个数字，统计其中的最大值和最小值并计算平均值，创建100个变量，会有一堆ifelse语句，比较麻烦。
数组是Java提供的一种最简单的数据结构，可以用来存储一个元素个数固定且类型相同的有序集。
数组在内存中的情况
栈：主要用于运行函数的内存
堆：主要用于存储数据对象的内存
每一个数组而言，都是存在堆内存当中，每一个数组都是一个对象

1、数组本质上就是在堆内存中一系列地址连续且空间大小相等的存储空间（变量），每一个存储空间用来存储数据（基本，引用）
2、数组是在堆内存中存储，称之为是一个对数对象，并且在堆内存中存储的数据都有默认初始化的流程。所以数组创建之初，每一个存储空间里面都会被JVM初始化该数据类型对应的零值。
3、数组的地址是连续的，所以通过公式：An=A1+(n-1)*d可以快速访问到其他的元素，所以对于数组而言查找元素比较快的。将元素的真实物理地址转换成对应的角标获取元素。
4、如何来调用数组呢？通过一个变量存储该数组在堆内存当中的首元素的地址。
5、当数组一旦定义出来，其长度不可变，存储空间的内容是可变的
6、所以我们在定义数组的时候，要么把长度固定，要么直接输入相关的元素。

数组的定义方式

//创建一个指定长度且指定数据类型的一维数组，名称为数组名，虽然没有指定元素，但是会有默认值
数据类型[] 数组名 = new 数据类型[长度];
//创建一个指定元素且指定数据类型的一维数组，名称为数组名，虽然有指定元素，还是有默认初始化这个步骤的！
数据类型[] 数组名 = new 数据类型[]{数据1,数据2,…,数据n};
数据类型[] 数组名 = {数据1,数据2,…,数据n};

public class Sample {
	public static void main(String[] args) {
		int[] arr = new int[5];
		System.out.println(arr[0]);
		//System.out.println(arr[5]);
		//ArrayIndexOutOfBoundsException
		arr[2] = 10;
		int[] arr2 = arr;
		System.out.println(arr2[2]);
		arr2 = null;
		//System.out.println(arr2[2]);
		//NullPointerException
		/*
		String s = null;
		s.length();
		*/
		arr = null;
	}
}

6.2 常用数组操作

数组遍历问题

public class Sample {
	public static void main(String[] args) {
		int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
		//String str str.length()-函数
		//int[] arr arr.length-属性
		for (int i = 0; i < arr.length; i++) {
			arr[i] = arr[i] * 10;
			System.out.println(arr[i]);
		}
		//通过角标遍历 可以在遍历的过程中对指定的元素进行修改
		//foreach遍历 主要针对的是一些可迭代对象 Iterable
		/*
		for (数据类型 变量名 : 可迭代容器) {
			}
		*/
		for (int num : arr) {
		//num -> arr[i]
			num = num / 10;
			System.out.println(num);
		}
		//这种遍历方式 只能获取元素，不能修改元素
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

数组最值问题

public class Sample {
	public static void main(String[] args) {
		int[] arr = new int[]{3,6,8,2,9,4,5,1,7};
		int min = arr[0];
		int max = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] < min) {
				min = arr[i];
			}
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		System.out.println(max);
		System.out.println(min);
	}
}

数组扩容问题

public class Sample {
	public static void main(String[] args) {
		int[] arr = new int[]{1,2,3,4,5};
		arr = add(arr,6);
		arr = add(arr,6);
		arr = add(arr,6);
		arr = add(arr,6);
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
		//在指定的数组arr中添加元素element
	public static int[] add(int[] arr, int element) {
		int[] newArr = new int[arr.length + 1];
		for (int i = 0; i < arr.length; i++) {
			newArr[i] = arr[i];
		}
		newArr[newArr.length - 1] = element;
		return newArr;
	}
}

选择排序算法

public class Sample {
//选择排序
	public static void main(String[] args) {
		int[] arr = {8,9,2,6,7,1,4,5,3};
		for (int i = 0; i < arr.length - 1; i++) { //-1 n个数字没有第n轮
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
				swap(arr,i,j);
				}
			}
		}
		print(arr);
	}
		//[1, 2, 3, 4, 5]
	public static void print(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length;i++) {
			System.out.print(arr[i]);
			if (i == arr.length - 1) {
				System.out.println("]");
			} else {
			System.out.print(", ");
			}
		}
	}
	public static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

冒泡排序算法

public class Sample {
//冒泡排序
	public static void main(String[] args) {
		int[] arr = {8,9,2,6,7,1,4,5,3};
		for (int i = 0; i <arr.length - 1; i++) {//-1 表示n个数字只有n-1轮
			for (int j = 0; j < arr.length - 1 - i; j++) {//-1 避免重复比较(当前最大和上一轮最大)
				if (arr[j] > arr[j + 1]) {
					swap(arr,j,j+1);
				}
			}
		}
		print(arr);
	}
	public static void print(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length;i++) {
			System.out.print(arr[i]);
			if (i == arr.length - 1) {
				System.out.println("]");
			} else {
				System.out.print(", ");
			}
		}
	}
	public static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

插入排序算法

public class Sample {
//插入排序
	public static void main(String[] args) {
		int[] arr = {8,9,2,6,7,1,4,5,3};
		for (int i = 1; i < arr.length; i++) {
			int e = arr[i];
			int j = 0;
			for (j = i; j > 0 && arr[j - 1] > e; j--) {
				arr[j] = arr[j - 1];
			}
			arr[j] = e;
		}
		print(arr);
	}
	public static void print(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length;i++) {
			System.out.print(arr[i]);
			if (i == arr.length - 1) {
				System.out.println("]");
			} else {
			System.out.print(", ");
			}
		}
	}
}

计数排序算法

public class Sample {
//计数排序
	public static void main(String[] args) {
		int[] arr = {-2,9,-1,12,8,-3,6,7,4,5,2,1,0,8,6,7,4,-3,-2,-1,-1,7};
		int min = arr[0];
		int max = arr[0];
		//O(n)
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] < min) {
				min = arr[i];
			}
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		int[] temp = new int[max - min + 1];
		//对应关系 index = number - min number = index + min
		//O(n)
		for (int i = 0; i < arr.length; i++) {
			temp[arr[i] - min]++;
		}
		//temp[index] 表示index对应的数字number出现的次数
		int k = 0;
		//O(n)
		for (int index = 0; index < temp.length; index++) {
			while (temp[index] != 0) {
				arr[k] = index + min;
				k++;
				temp[index]--;
			}
		}
		print(arr);
	}
	public static void print(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length;i++) {
			System.out.print(arr[i]);
			if (i == arr.length - 1) {
				System.out.println("]");
			} else {
			System.out.print(", ");
			}
		}
	}
}

基数排序算法

import java.util.LinkedList;
public class Sample {
//基数排序
	public static void main(String[] args) {
		int[] arr = {102,203,321,13,12,78,96,34,37,28,6,8,5,6};
		//1.先找到最大值 决定轮数
		int max = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		int radex = (max + "").length();
		//2.创建十个桶 每一个桶是LinkedList
		LinkedList<Integer>[] queues = new LinkedList[10];
		for (int i = 0; i < queues.length; i++) {
			queues[i] = new LinkedList<Integer>();
		}
		//3.进行数字分类和规整
		//r=0个位 r=1十位 r=2百位...
		for (int r = 0; r < radex; r++) {
		//先按照r进行分类
			for (int i = 0; i < arr.length; i++) {
				int index = getIndex(arr[i],r);//获取数字的r位 返回该数字要去的桶的角标0~9
				queues[index].offer(arr[i]);
			}
			//然后在重新规整到arr里
			int k = 0;
			for (int index = 0; index < queues.length; index++) {
				while(!queues[index].isEmpty()) {
				arr[k++] = queues[index].poll();
			}
		}
	}
	print(arr);
}
	public static int getIndex(int number, int r) {
		//123 r=0
		//123 r=1
		//123 r=2
		int index = 0;
		for (int i = 0; i <= r; i++) {
			index = number % 10;
			number /= 10;
		}
		return index;
	}
	public static void print(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length;i++) {
			System.out.print(arr[i]);
			if (i == arr.length - 1) {
				System.out.println("]");
			} else {
				System.out.print(", ");
			}
		}
	}
}

二分查找算法

有一个前提，所查找的数据集必须是有序的（升序，降序）

public class Sample {
//二分查找
	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5,6,7,8,9};
		int min = 0;
		int max = arr.length - 1;
		int mid = (min + max) / 2;
		int key = 10;
		while (arr[mid] != key) {
			if (key < arr[mid]) {
				max = mid - 1;
			}
			if (arr[mid] < key) {
				min = mid + 1;
			}
			if (min > max) {
				mid = -1;
				break;
			}
			mid = (min + max) / 2;
		}
		System.out.println(mid);
	}
}

可变长参数列表

public class Sample {
	public static void main(String[] args) {
		show(1);
		show(1,2,3);
		show("hehe","lala","haha","xixi","heihei");
	}
	public static void show(int ... nums) {
		for (int i = 0; i < nums.length; i++) {
			System.out.print(nums[i] + " ");
		}
		System.out.println();
	}
	public static void show(String ... strs) {
		for (int i = 0; i < strs.length; i++) {
			System.out.print(strs[i] + " ");
		}
		System.out.println();
	}
}

6.3 二维数组

二维数组，在表现形式上就是一个表格，在操作表格的时候以行列来操作
所谓的二维数组，本质上就是一个一维数组，只不过该一维数组里面的元素是另一个一维数组而已

二维数组的定义

public class Sample {
	public static void main(String[] args) {
	//数据类型[][] 矩阵名 = new 数据类型[row][col];
		int[][] matrix = new int[3][2];
	/*
	数据类型[][] 矩阵名 = new 数据类型[][] {
	{...},
	{...},
	{...}
	};
	数据类型[][] 矩阵名 = {
	{...},
	{...},
	{...}
	};
	*/
		int[][] matrix2 = {
		{1,2,3},
		{4,5,6},
		{7,8,9}
		};
		for (int i = 0; i < matrix2.length; i++) {
			for (int j = 0; j < matrix2[i].length; j++) {
				System.out.print(matrix2[i][j] + " ");
			}
		System.out.println();
		}
		int[][] matrix3 = {
		{1},
		{1,2,3},
		{1,2,3,4},
		{7,6,5,4,3,2,1}
		};
		for (int i = 0; i < matrix3.length; i++) {
			for (int j = 0; j < matrix3[i].length; j++) {
				System.out.print(matrix3[i][j] + " ");
			}
			System.out.println();
		}
	}
}

你可能感兴趣的:(JavaSe,java)

蓝桥杯历年真题JAVA版-2016年蓝桥杯省赛- Java组 Roc-xb 蓝桥杯 java 算法
第1题——生日蜡烛（1）题目描述某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。现在算起来，他一共吹熄了236根蜡烛。请问，他从多少岁开始过生日party的？输出格式：请填写他开始过生日party的年龄数。（2）解题代码publicstaticvoidfunc1(){for(inti=0;i236)//若从年龄i累加，超过了236，终止循环{break;}if(s
java web + mysql 实现图书管理系统鱼弦【练习两年半】程序基础【HOT】技术热谈 mysql 数据库
鱼弦：CSDN内容合伙人、CSDN新星导师、51CTO(Top红人+专家博主)、github开源爱好者（go-zero源码二次开发、游戏后端架构https://github.com/Peakchen）要使用JavaWeb和MySQL实现图书管理系统，你可以按照以下步骤进行操作：数据库设计：创建一个MySQL数据库，并命名为图书管理系统。设计数据库表，例如：图书表（Book）、用户表（User）等。
如何设计基于Java的高并发消息队列系统省赚客app开发者 java 开发语言
如何设计基于Java的高并发消息队列系统大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在现代的分布式系统中，消息队列作为解耦和异步处理的关键组件，能够有效提升系统的可扩展性和高并发处理能力。本文将详细探讨如何设计一个基于Java的高并发消息队列系统，包括架构设计、核心组件实现及性能优化策略。一、消息队列系统的需求分析在设计高并发消息队列系统时，需要考虑以下几个核心需
Java应用中的高可用架构设计：从单点故障到故障恢复省赚客app开发者 java 开发语言
Java应用中的高可用架构设计：从单点故障到故障恢复大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！高可用架构设计是现代软件开发中的关键组成部分，尤其是在Java应用中。高可用性不仅能够提高用户满意度，还能减少因服务不可用导致的业务损失。本文将探讨如何从单点故障到故障恢复，构建一个高可用的Java应用架构。一、高可用性的定义与重要性高可用性（HighAvailabil
Java中的API设计与版本管理：RESTful API的最佳实践省赚客app开发者 java restful 开发语言
Java中的API设计与版本管理：RESTfulAPI的最佳实践大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在现代软件开发中，API（应用程序接口）设计与版本管理是至关重要的。RESTfulAPI由于其简洁性和可扩展性，已经成为了最流行的Web服务架构风格。本文将探讨Java中如何设计和管理RESTfulAPI，提供最佳实践和实用的技术方案。1.RESTfulAP
（尚硅谷 java 学习 b 站大学版）Day11 面向对象基础知识初入门亢从文_Jackson java 学习 python
四、面向对象(上)终于到面向对象了，Java语言的重中之重奥利给！！！Java面向对象学习的三条主线：1、Java类及类的成员：属性、方法、构造器；代码块内部类2、面向对象三大特征：封装、继承、多态性、(抽象性)3、其他关键字：this\super\static\final\abstract\interface\package…4.1面向过程（POP）与面向对象(OOP)面向过程：强调是功能行为，
ecmascript标准周盛欢 ecmascript
一、什么是ECMAScriptECMAScript是一种脚本语言的标准，由EcmaInternational组织制定。简单来说，它就是JavaScript的“官方规范”，规定了JavaScript语言的语法和行为。就像英语有语法一样，JavaScript也有自己的“语法书”，而ECMAScript就是这本“语法书”。二、为什么需要ECMAScript以前，不同的浏览器（比如Chrome、Firef
2025蛇年喜庆HTML5代码学习&实践爱好者 HTML5与CSS3 JavaScrip技术编程实践系列 html5 前端 html
2025蛇年喜庆HTML5代码以下是一个简单的HTML5+CSS+JavaScript代码示例，用于庆祝2025年蛇年。先看效果图：源码如下：2025年蛇年快乐！body{font-family:'Arial',sans-serif;background-color:#0a0a23;/*深蓝色背景*/color:#ffffff;/*白色文字*/text-align:center;margin:0;
Java软件架构中的事件驱动模式：最佳实践与挑战省赚客app开发者 java 开发语言
Java软件架构中的事件驱动模式：最佳实践与挑战大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来聊一聊**事件驱动架构（Event-DrivenArchitecture,EDA）**在Java软件开发中的应用。事件驱动模式已经成为现代分布式系统中广泛采用的设计方式，尤其是在需要解耦组件、提高系统响应能力和支持高并发的场景下。本文将探讨事件驱动架构的最佳实践以
ZooKeeper 提供了什么？思维导图代码示例（java 架构) 用心去追梦 java-zookeeper zookeeper java
ZooKeeper提供了一组核心服务和特性，旨在简化分布式系统的构建。它通过一个简单的接口来实现同步、配置管理、分组和命名等功能。下面我将提供一个关于ZooKeeper所提供的服务和特性的思维导图大纲，并给出一些Java代码示例以说明如何使用这些功能。思维导图大纲1.ZooKeeper提供的核心服务命名服务（NamingService）分布式系统中唯一标识资源配置管理（ConfigurationM
生产环境WAS产生javacore、dmp、dump文件分析 bubble小拾 1024程序员节 java 运维
目录一、分析工具二、Java转储（Javadump）Java转储内容（Javadumpcontents）标题(TITLE)GP信息（GPINFO）环境信息（ENVINFO）本地内存信息（NATIVEMEMINFO）内存信息（MEMINFO）锁（LOCKS）线程（THREADS）钩子（HOOKS）共享类（SHAREDCLASSES）类（CLASSES）场景（Scenarios）一般保护故障（Gene
Java程序员开发软件(工具)清单 nshkfhwr Java MySQL Linux java tomcat maven kafka eclipse
亲！你准备好了吗？【001】项目管理：禅道/JIRA【002】办公协同：钉钉【003】工作邮件：Foxmail/OutLook【004】项目文档：MS-Office(Word/Excel/PowerPoint)/WPS【005】MD-笔记：Typro【006】个人PKM：Zim-Wiki/思源笔记【007】ToDO清单：Todo清单【008】文件搜索：Everything【009】桌面整理：Fen
activeMQ笔记之一 kongxiangqi activemq jms session 消息中间件 api 企业应用
1.JMS介绍JMS源于企业应用对于消息中间件的需求，使应用程序可以通过消息进行异步处理而互不影响。Sun公司和它的合作伙伴设计的JMSAPI定义了一组公共的应用程序接口和相应语法，使得Java程序能够和其他消息组件进行通信。JMS有四个组成部分：JMS服务提供者、消息管理对象、消息的生产者消费者和消息本身。1)JMS服务提供者实现消息队列和通知，同时实现消息管理的API。JMS已经是J2EEAP
java 字符串日期字段格式化前端显示 qq_36608622 java 开发语言
在Java应用程序中，如果你有一个字符串类型的日期字段，并希望将其格式化后显示在前端，可以通过多种方式实现。这通常涉及到在后端将字符串转换为Date或LocalDateTime等对象，然后使用适当的注解或配置来确保它们以正确的格式序列化为JSON发送到前端。以下是几种常见方法：方法一：使用@JsonFormat注解(Jackson)如果你使用的是Jackson来处理JSON序列化和反序列化，可以在
刷题前必学！链表！用JavaScript学数据结构与算法
‍JavaScript数据结构与算法-HowieCong务必要熟悉JavaScript使用再来学！一、链表的基本形态链表和数组都是有序的列表，都是线性结构（有且仅有一个前驱，有且仅有一个后续）；不同点在于，链表中，数据单位的名称叫做“结点”，而结点和结点的分布，在内存中都是离散的1.数组的“连续”在内存中最为关键的一个特征，就是对应一段位于自身上界和下界之间的，一段连续的内存空间。元素与元素之间，
ambari-server页面错位问题解决王木头 ambari hadoop 大数据
背景：项目新安装的ambari集群页面错位如下解决办法（临时）：修改ambari-server的前端文件：/usr/lib/ambari-server/web/javascripts/app.js原代码：initNavigationBar:function(){if(App.get('router.mainController.isClusterDataLoaded')){$('body').on
前端的核心技术善良的小乔前端
前端开发的核心技术主要围绕HTML、CSS、JavaScript三大基础语言展开，同时结合现代前端开发的需求，还包括前端框架、构建工具、前端安全和性能优化等内容。下面，我们详细解析前端开发中的核心技术。一.HTML（超文本标记语言）详解HTML（HyperTextMarkupLanguage）是前端开发的基础，用于构建网页的结构。HTML由各种标签（Tag）组成，每个标签都有不同的作用，主要用于定
华为OD机试算法目录题库-1 国王护卫队华为OD面试最新手撕代码华为od 算法 python
(D卷,200分)-攀登者2（Java&JS&Python&C）(D卷,100分)-最大时间（Java&JS&Python）(D卷,200分)-最长子字符串的长度(二)（Java&JS&Python&C）(D卷,200分)-最小矩阵宽度（Java&JS&Python&C）(D卷,200分)-最小传输时延Ⅱ（Java&JS&Python）(D卷,200分)-最大社交距离（Java&JS&Python
CSS3网页加载进度条特效：13种炫酷实现 laforet
本文还有配套的精品资源，点击获取简介：本文深入探讨CSS3在网页加载进度条设计中的应用，包括动画、选择器、边框半径、过渡和阴影等新特性。通过介绍13种不同的进度条特效代码，指导开发者如何结合JavaScript实现丰富的进度显示效果，提升用户体验。详细描述了进度条的外观设计和动态效果，如计数器进度条、顶部进度条、背景进度条，并展示了利用Flexbox、Grid布局、Transforms、阴影和渐变
【网站架构部署与优化】Tomcat优化、Tomcat多实例部署 Karoku066 架构 tomcat firefox linux 运维服务器 bash
文章目录Tomcat优化Tomcat配置文件参数优化示例配置TomcatJVM参数配置参数解释注意总结Tomcat配置文件参数优化(`server.xml`)1.线程池参数2.网络连接参数3.性能优化参数Java虚拟机（JVM）调优1.堆内存设置2.新生代和老年代设置3.垃圾收集器设置4.其他性能优化参数常见错误及解决方法Tomcat多实例部署1.安装JDK和Tomcat2.配置Tomcat环境变
使用CSS实现一个加载的进度条 eqa11 css 前端进度条
文章目录使用CSS实现一个加载的进度条一、引言二、步骤一：HTML结构与CSS基础样式1、HTML结构2、CSS基础样式三、步骤二：添加动画效果1、使用CSS动画2、结合JavaScript控制动画四、使用示例五、总结使用CSS实现一个加载的进度条一、引言在现代网页设计中，加载速度对用户体验至关重要。为了提升用户体验，加载进度条成为了一个常见的交互元素。它不仅能告知用户页面加载的进度，还能减少用户
2024 java面试题 TPBoreas #Java面试开发语言后端
目录JAVA初级请简述你对MVC模式的理解SpringBean的生命周期可以分为以下几步:Spring自动装配bean有哪些方式？说一下类的加载过程？在使用HashMap的时候，用String做key有什么好处？HashMap、LinkedHashMap、TreeMap的区别？this与super之间有什么区别？乐观锁和悲观锁的实现是怎么样的？==与equals的区别Final在java中有什么作
[0157]基于JAVA的井下瓦斯及灾害预警智慧管理系统的设计与实现阿鑫学长【毕设工场】 java 开发语言毕业设计课程设计
毕业设计（论文）开题报告表姓名学院专业班级题目基于JAVA的井下瓦斯及灾害预警智慧管理系统的设计与实现指导老师（一）选题的背景和意义选题背景与意义：随着我国煤炭工业的持续发展，井下安全生产问题特别是瓦斯灾害防治成为制约煤矿高效、安全运营的关键环节。据统计数据显示，瓦斯爆炸事故在各类煤矿安全事故中占据较高比例，严重威胁矿工生命安全和煤矿生产秩序。因此，实现对井下瓦斯浓度的实时监测、智能预警以及高效的
【架构师基础（二）】Java 架构设计的基本原则架构学院 Java成神之路-架构师进阶 java 开发语言架构设计模式
Java架构设计的基本原则：构建稳健、可维护和可扩展的系统在Java开发领域，架构设计是构建高质量软件系统的关键环节。良好的架构不仅能保证系统在当前的正常运行，还能确保其在未来的扩展、维护和优化过程中保持高效和可靠。本文将深入探讨Java架构设计的一些基本原则，包括SOLID原则、设计模式以及代码重构对可维护性的影响，并通过实际的源码示例来详细阐述它们的实现原理、性能考量和应用场景。无套路、关注即
深入了解 React：从入门到高级应用 ╰つ゛木槿 web前端 react.js 前端前端框架
深入了解React：从入门到高级应用React是由Facebook开发并维护的一个开源JavaScript库，用于构建用户界面。自2013年发布以来，React在前端开发领域迅速崛起，成为最受欢迎的UI构建工具之一。无论是小型的单页应用（SPA）还是复杂的大型企业级应用，React都能提供高效、灵活的解决方案。本文将全面、详细地介绍React，包括其核心概念、工作原理、最佳实践以及生态系统。目录：
java JDBC操作Mysql解析一只肥瘫瘫 java java mysql 数据库
一.概念：JavaDataBaseConnectivityJava数据库连接，Java语言操作数据库。JDBC本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。二.操作步骤：1.导入驱动jar包2.注册驱动3.获取数据库连接对象Connect
（面经总结）一篇文章带你整理面试过程中关于多线程中的线程池的相关知识点南淮北安冲刺大厂之面经总结面试 java 经验分享线程池多线程
文章目录一、线程池的工作原理二、线程复用三、线程池的核心组件和核心类四、Java线程池的工作流程五、线程池的拒绝策略六、5中常用的线程池1.newCachedThreadPool2.newFixedThreadPool3.newScheduledThreadPool4.newSingleThreadExecutor5.newWorkStealingPool六、面试题一、线程池的工作原理线程是非常宝
jhyperscan性能优化过程大明__ hyperscan java c++
因业务需求，对正则匹配进行优化，使用hyperscan进行文本内容提取优化；Hyperscan是一款来自于Intel的高性能的正则表达式匹配库；因为业务代码是java编写的，所以参照hyperscan-java的方法，使用C/C++编译Hyperscan，然后使用JNA调用的方式使用Hyperscan；不过经性能测试，发现Hyperscan-java，并未能产生明显的性能优化；隧开始定位为什么Hy
【Java 线程池】详解架构学院 Java成神之路-JAVA入门 Java成神之路-架构师进阶 java spring spring boot spring cloud jvm
线程池详解无套路、关注即可领。持续更新中关注公众号：搜【架构研究站】回复：资料领取，即可获取全部面试题以及1000+份学习资料在现代的Java并发编程领域，线程池扮演着至关重要的角色。它不仅能高效地管理线程资源，避免频繁创建和销毁线程带来的性能开销，还能提升系统整体的并发处理能力与稳定性。接下来，我们将深入剖析线程池的方方面面，包括其原理、核心组成部分、使用方法以及在实际项目中的具体运用。一、线程
JavaScript简介、如何在HTML中使用JavaScript以及JavaScript基本概念 v.15889726201 javascript html udp
一、JavaScript简介一个完整的JavaScript实现应该由ECMAScript（核心）、DOM（文档对象模型）、BOM（浏览器对象模型）三个不同的部分组成；ECMAScript提供核心语言；DOM（DocumentObjectModel）把整个页面映射为一个多层节点结构，是针对XML但经过扩展用于HTML的应用程序编程接口（API），借助DOM提供的API，开发人员可以轻松自如地删除、添
redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSource expire/del incr/lpush 数据库分区 redis
最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷） 1、关于JedisPool.returnSource(Jedis jeids) 这个方法是从red
SQL性能优化-持续更新中。。。。。。 atongyeye oracle sql
1 通过ROWID访问表--索引你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
[JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
lvs- real 男人50 LVS
#!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #. /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
生成公钥和私钥 oloz DSA 安全加密
package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
UIView 中加入的cocos2d，背景透明 374016526 cocos2d glClearColor
要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
mysql常用命令香水浓 mysql
连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScript jquery css html5
系统层面：高可用性所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
利用ant进行远程tomcat部署 aijuans tomcat
在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
获取复利总收入 baalwolf 获取
public static void main(String args[]){ int money=200; int year=1; double rate=0.1; &
eclipse.ini解释 BigBird2012 eclipse
大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
AngularJS实现分页功能 bijian1013 JavaScript AngularJS 分页
对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。 &nbs
[Maven学习笔记三]Maven archetype bit1129 ArcheType
archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等. mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式， mvn archetype 1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
【Java命令三】jps bit1129 Java命令
jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看 [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学 unity教程 unity视频 unity资料 unity
unity 3d还是cocos2dx哪个适合游戏？问：unity 3d还是cocos2dx哪个适合游戏？答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java 算法面试百度招聘
import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
获取checkbox复选框的值 chiangfai checkbox
<title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
MySQLdb用户指南 chenchao051 mysqldb
原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
HIVE 窗口及分析函数 daizj hive 窗口函数分析函数
窗口函数应用场景：（1）用于分区排序（2）动态Group By （3）Top N （4）累计计算（5）层次查询一、分析函数用于等级、百分点、n分片等。函数说明 RANK() &nbs
PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHP zip
PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
精彩英语贺词 dcj3sjt126com 英语
I'm always here 我会一直在这里支持你 &nb
基于Java注解的Spring的IoC功能 e200702084 java spring bean IOC Office
java模拟post请求 geeksun java
一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
Swift语法之 ---- ?和!区别 hongtoushizi ?swift !
转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
centos7安装jdk1.7 jisonami jdk centos
安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
数据源架构模式之数据映射器 home198979 PHP 架构数据映射器 datamapper
前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。一、概念数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
在Python中使用MYSQL pda158 mysql python
缘由　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到数据库中。　　了解到 Python在这方面有优势，便选用之。　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里记录一下，大家共勉。　　 python中mysql的调用　　百度之后能够通过MySQLdb进行数据库操作。
单例模式 hxl1988_0311 java 单例设计模式单件
package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。