IDEA 创建运行简单JAVA程序_Reine_X的博客-CSDN博客_idea运行java程序
IDEA配置环境_热水瓶、的博客-CSDN博客_idea 环境配置
1.搭建环境
1.基本环境
java JDK 1.8 、maven 3.5.x、Tomcat 9.x、mysql-jdbc
2.常用java命令
java -version java版本
mvn -v mavern版本
快捷键盘(psvm + tab)
public static void main(String[] args) {。。。}
快捷键盘(sout + tab)
System.out.println("")
快捷键盘(alt + insert)
调用generater接口中的(setter,getter,重载方法)
快捷键盘(alt + Enter)
导入当前光标位置的类， 推荐设置返回值 ，默认接口重写方法
快捷键盘(ctrl + F12)
查看类中的方法
快捷键盘(ctrl + d) 复制当前行
快捷键盘(ctrl + x) 删除当前行
快捷键盘(ctrl + c) 选中当前行
强调java非常严格，一般双引号和单引号别混用
3.运行java程序
java原生语句
// 编译源程序，形成字节码文件
命令：javac tome\jiafei\Student.java
javac tome\jiafei\MainExample.java
命令：javac *.java
// 运行程序
命令：java tom.jiafei.MainExample
4.jre扩展与jar文件
将jar文件放在 jdk的安装目录， jre\lib\ext, 在java中就可以使用这个扩展了。
1.编译moon.star包下的 TestOne, TestTwo源文件(项目的目录)
命令： javac moon.star.TestOne.java
javac moon.star.TestTwo.java
2.编写清单文件(Mainfestfiles)放在根目录
hello.mf 内容如下
Manifest-Version: 1.0
Class: moon.star.TestOne moon.star.TestTwo
Created-By: 1.8
3.打包成jar文件
命令：jar cfm Jerry.jar hello.mf moon\star\*.class
4.然后放在jre指定目录下，就可以使用import 导入模块了
import moon.star.*;
5.配置maven
maven目录->conf->settings.xml, 在本地新建一个文件，作为本地仓，添加第56行配置，将新建文件路径写入，重启项目
<localRepository>C:\Apps\ComputerWorkStation\JavaEclipse\apache-maven-3.8.6\maven_repository</localRepository>
6.IDea 运行程序
- 在新窗口打开一个 项目
- 编译java文件， 配置configuration-》 Application -》 Main class, Working directory, use classpath of module, shorten command (直接右键运行也可以)
2.基本数据类型
1.基本概念
1个字节8位
逻辑类型： boolean
整数类型： byte, short, int, long
字符类型： char
浮点类型： float, double
byte 1个字节
char 2个字节
int 4个字节，
short 2个字节
long 8个字节
float 4个字节
double 8个字节，
获取最大，最小的取值范围 Byte.MIN_VALUE, Byte.MAX_VALUE
unicode字符集将，所有的国家的语言都用独有的编码技术，以前gbk, ascii, 都是用两个字符表示一个中文，因此在实际开发中，对统一字符集编码并不友好。
2.类型转换
int a = (int)b
int c = (float)d
3.输入，输出语句
import java.util.Scanner;
// 获取窗口输入句柄
Scanner reader = new Scanner(System.in);
// 获取输入信息
boolean a = reader.nextBoolean();
byte a = reader.nextByte();
int a = reader.nextInt();
long a = reader.nextLoong();
float a = reader.nextFloat();
double a = reader.nextDouble();
String a = reader.next();
String a = reader.nextLine();
// 输出信息
// 换行输出
System.out.println(a)
System.out.println(str1+str2)
// 不换行输出
System.out.print(a)
// 格式化输出
System.out.printf("%d%c%%f%s",(int)a,(char)a,(float)a,(string)a)
%md int占n列
%m.nf float占m列，保留n位小数
4.基本的声明和使用
Double d = 100D
double d = 100D 大写和小写是等价的
int a = 1/0 是异常的
3.String 字符串
1.字符串的初始化
// 创建变量
String s = new String("Java")
// 创建常量 （两者并不能相等）
String s = "你好"
// ”+“ 并置运算，常量结果不变，而变量的结果却不能直接等于
String new_s = s1 + s2;
// 将字符数组转换成字符串
char a[]={'a','b','c'}
String s = new String(a) // 全部转换
String s = new String(a,0,2) // 部分转换指定长度的
2.常用方法
int len = s1.length() // 字符串长度
boolean b = s1.equals(s2) // 直接比较两个字符串的值
boolean b = s1.equalsIgnoreCase(s2) // 忽略大小写比较
boolean b = s1.startsWith("a") // 前缀匹配
boolean b = s1.endsWith("a") // 后缀匹配
int b = s1.compareTo(s2) // 比较大小,返回:正数，0，负数
int b = s1.compareToIgnoreCase(s2) // 忽略大小写，比较大小
boolean b = s1.contains(s2) // 包含匹配
int b = s1.indexOf(s2) // 子串索引位置 (首次匹配)
int b = s1.lastIndexOf(s2) // 子串索引位置 (最后一次匹配)
int b = s1.indexOf(s2,0) // 子串索引位置,指定位置开始匹配
String s1 = s1.substring(0) // 子串切割，指定位置开始匹配
String s1 = s1.trim() // 前后空格去除
String s1 = obj.toString() // 对象的输出方法,转换为字符串
boolean b = obj.getClass.equals(String.class) // 判断是否是字符串
3.字符串到基本类型的转换
int x = Integer.parseInt("123456") // 从字符串中解析出整型
int x = Float.parseFloat("123456.1") // 从字符串中解析浮点型
int x = Double.parseDouble("123456") // 从字符串中解析double类型
String s1 = String.valueOf(123) // 从整型中转换成字符串
String s2 = String.valueOf(123.1) // 从浮点型中转换成字符串
4.字符串与正则表达式
boolean b = s1.matches("[a-z]+") // 是否可以匹配到结果
String s2 = s1.replaceAll("[a-z]+","1") // 全部替换结果
String s2[] = s1.split("[;]") // 字符串分割，返回字符串数组
5.字符串与字符数组（一般是用于加密）
char a[] = new char[10];
s1.getChars(0,10,a,0) // 将字符串存储到字符数组，start,len, arr, offset
char c[] = s1.toCharArray() // 将字符串完整地转换成字符数组
byte b = s2.getBytes() // 将字符串完整地转换成字节数组 (特殊)
4.正则表达式
1.元字符
元字符 正则表达式 含义
\d \\d 或 \\p{Digit} 0-9中的数字 或 [0-9]
\D \\D 或 \\p{Blank} 非数字字符 或 \x0B,\t
\s \\s 空格类字符， \t,\n,\f,\r, \x0B
\S \\S 非空格类字符
\w \\w 单词类字符
或 \\p{Lower} 或 \\p{Upper} 或 \\p{ASCII} 或 \\p{Alnum}
或 小写字符 或 大写字符 或 ascii字符 或 字母\数字类字符
\W \\W 非单词类字符
2.限定符
修饰符 意义
? 出现0或者1次
* 出现0或者多次
+ 出现1或者多次
{m} 出现m次
{m,} 至少出现m次
{m,n} 出现m到n次
| X或Y
^,$ 前缀，后缀匹配
[^] 非前缀匹配
2.使用实例
[^abc] 除abc以外的字符
[a-zA-Z] 英文字母字符
[a-d[m-p]] a~d,或者m-p的任何一个字符
[a-z&&[def]] d,e,f中任何一个
[a-z&&[^bc]] 非bc的英文小写字符
[.] 或者 \56 表示普通意义的点
5.Arrays数组使用
注意点：与C语言不同，Java不允许在声明数组的中方括号内指定数组元素的个数
1.声明数组
// 一维数组
int a[],b[];
// 二维数组
int a[][];
// 可以进行初始化，同时也分配了空间
int a[]= {1,2,3}
2.为数组分配空间（在分配空间的同时，也可以采用常量）
a = new float[4]
a = new float[4][5]
// c语言是需要使用宠定义的变量，而不是变量。
size = 20;
a = new float[size]
3.动态分配二维数组
a = new float[3][];
a[0] = new float[4]
a[1] = new float[5]
a[2] = new float[6]
4.数组的引用(在相同的分配空间大小)
a = b
5.数组的常用方法
int len = a.length; // 获取数组长度
String str = Arrays.toString(a) // 数组转换成字符串
Array.sort(a); // 数组排序
int index = Arrays.binarySearch(arr,"hello") // 数组索引
6.运算符,表达式
1.条件分支结构
if(){ ... }else{ ... }
if(){ ... }else if(){ ... }
2.switch开关结构
switch(){
case '': break;
default: break;
}
3.循环语句
for(int i=0;i<x;i++){ ... }
while(){ ... }
do{ ... }while();
// 控制流程的关键 词
break, continue
// for each 循环
for(int arr:x){ sum = sum + x }
4.创建函数
void xxx(){ ... }
float xxx(){ ... }
5.可变参数 ...
void hello(int a,int ... x){ ... }
// x是一个形参数组
6.变量
java允许定义中文的变量，类名方法。
double 变量 = 1;
void 方法(){ ... }
7.import模块引入
1.package包名
package tom.hello;
2.import导入
import tome.hello.*;
// 默认的类库
java.lang.* 包含 所有的基本语言类
javax.swing.* 包含抽象窗口工具集中的图形，文本，窗口GUI类
javax.io.* 包含所有的输入和输出类
javax.util.* 包含实用类
javax.sql.* 包含操作数据库的类
javax.net.* 包含所有实现网络功能的类
8.class类与对象
1.初始化类
class 类名{
// 以下是类体
// 1.构造方法(默认有一个构造方法)
// 可以设置为带参，不带参，带默认参数的构造方法。（允许定义两种不冲突的方法访问）
类名(int x1){
// super方法
super()
x = 1;
}
// 2.成员变量
float a ;
// 成员方法
float getData(){
return a; // 直接访问
return this.a; // 通过this访问(如果形参与成员变量相同的情况下，就需要使用this.)
}
void setData(float a1){
a = a1;
}
// 3.类变量
static int y;
// 类方法
static int setData(a){
y = y1
};
// 4.形参中也可以使用类形参
double computerArea(Circle c){
return c.getArea();
}
// 5.修饰符号 private, protected, public， 空 （私有， 保护， 公有， 友好形）
// 可以创建私有变量，方法， 保护变量，方法， 公有变量，方法
// 没有任何修改符号，就是友好变量，友好方法，友好类 ，
// 一般要求继承的方法和类必须是非友好类。并且权限需要高于基类(父类), 并且友好类只能在同一个包中使用
// 权限高低： public, protected, 友好的， private
private int a = 0;
protected void getData(){
...
}
}
// 1.创建对象
类名 a= new 类名()
a.getData();
a.height;
// 2.对象的引用
// java也有"垃圾回收机制“
a = b;
// 自动清理，立即执行”垃圾收集“操作
System.gc()
// 强制退出程序
System.exit(0)
// 4.static 类方法和类变量的调用
// 类变量中不能使用成员方法，只能使用类变量。
类名.y
类名.getData()
// 5.final 常量
// final可以修饰类，变量，方法， 但被修饰的对象，不能补继承，重写，变更
final class A{ ... }
final int a = 0;
// 6.对象数组
Student stu[]; // 声明对象数组
stu = new Student[10]; // 定义数组的元素
for(int i=0;i<stu.length;i++){
stu[i] = new Student(); // 为每个元素创建Student对象
}
// 7.对象的上转型对象
//当子类创建一个对象，并把这个对象的引用放到父类的对象中
// 上转型对象操作子类继承的方法或者子类重写的实例方法，其作用等价于子类对象去调用这些方法， 因为型对象只能访问子类继承的成员变量或者成员方法。
Animal a = new Tiger();
// 强制将对象的上转型对象转换到一个子类对象
子类对象 = （子类类名）父类对象
Animal b = (Animal) a
// 8.内部类
可以在类里面再 定义一个类，并且需要在类进行初始化时，创建内部类的对象
同时，也可以直接去创建内部类的对象。
A.InnerA a = new A.InnerA();
a.hello()
2.类的重载,重写
类的多态性表现在： 重载， 重写， 而重写是继承实现的多态， 重载是一个类中出现多个不同参数的成员方法。
class Student extends People{
// 重载方法
// 注意点，不要是同类型的形参，只替换参数位置的情况。
float hello(int a){
...
}
float hello(int a, int b){
...
}
// 重写方法, 父类和子类有相同的方法，但通过子类创建的对象，调用的方法是子类重写的新方法
function getData(){
...
}
}
3.类的继承
友好类只能在同一个包中使用，一般要求继承的方法和类必须是非友好类和 private权限。并且权限需要高于基类(父类)
如果需要被其它文件引用，则需要设置为public,才能被正常访问
class A{
...
}
class B extends A{
// 显示创建类的构造方法，需要调用super(), 来调用父类的构造方法
B(){
super();
height = 1;
}
// super关键字获取父类的属性或者方法
void getData(){
super.getData();
}
}
4.抽象类
注意：不允许使用final和abstract 同时修饰一个方法或者类， 并且也不允许使用static修饰abstract方法
abstract class A{
// 只有抽象类才允许出现抽象方法
abstract int min(int x,int y);
// 普通方法
int max(int x,int y){
return x>y ? x : y;
}
}
// 如果子类需要继承抽象类，则必须重写父类的抽象方法，写出方法体。
class B extends A{
// 重写父类的方法
int min(int x,int y){
return x<y ? x : y;
}
}
注意：设置的类，设计的系统，尽量符合”开-闭原则 “， 这样做出的系统才易维护
5.接口和实现
// 接口比抽象类更加灵活，它只有抽象方法，所有的方法是 public static final xxx
// 1.定义接口
interface Printable{
(public static final) int Max = 900;
(public) abstract void add();
}
// 2.实现接口
class A extends B implements C,D{
// 写出抽象方法的方法体
public void add(){
...
}
// 可以直接访问接口的常量
int a = C.Max;
}
// 3.接口回调（类似上转型对象）
Printable sm; // 声明接口变量
sm = new A(); // 接口变量中存放对象的引用
sm.add(); // 接口回调。
9.常用的类
import java.util.Date; 实用类（Date, Math, System)
1.Date类
Date date = new Date()
// 获取当前日期的字符串
String a = date.toString();
// 记录当前执行时间
Long startTime = System.currentTimeMillis();
2.Calendar类
Calendar canlendar = Calendar.getInstance()
// 当前时间戳
int m = canlendar.currentTimeInMillis();
Date date = new Date(m);
// 设置日期
canlendar.setTime(new Date())
canlendar.set(2020,1,1)
canlendar.set(2020,1,1,9,30,0)
// 获取日期
canlendar.get(Calendar.YEAR) // 当前年份
canlendar.get(Calendar.MONTH) // 当前月份
canlendar.get(Calendar.DAY_OF_MONTH) // 当前日期
canlendar.get(Calendar.HOUR_OF_DAY) // 当前小时
canlendar.get(Calendar.MINUTE) // 当前时间
canlendar.get(Calendar.SECOND) // 当前分钟
日期格式化
// 1.SimpleDateFormat格式化
import java.text.SimpleDateFormat;
SimpleDateFormat m = new SimpleDateFormat("hh:mm:ss")
// 2.字符串的format方法
// 第一个参数可以填写地区， 默认 Locale.CHINA, 可以设置为其它Locale.US
Date nowTime = new Date();
String s1 = String.format("%tY-%tm-%td",nowTime,nowTime,nowTime)
String s1 = String.format("%tH:%tM:%tS",nowTime,nowTime,nowTime)
2.Math,Random类
1.Math类
import java.lang.math;
int a = Math.sqrt(a) // 开平方
int a = Math.random() // 获取随机数 [0-1)
int a = Math.abs(a) // 求绝对值
int a = Math.max(a,b) // 求绝对值
int a = Math.min(a,b) // 求绝对值
int a = Math.pow(a,2) // 求绝对值
int a = Math.ceil(a) // 大于a的最小整数
int a = Math.floor(a) // 不大于a的最大整数
int a = Math.round(a) // 四舍五入，
// 正数大于，等于0.5就入， 小于就舍; 负数大于0.5才入，小于等于就舍弃。(先不考虑符号，结束后才添加符号)
2.random类
import java.util.random;
使用Math模块获取指定整数
int a = (int)(Math.random() * 100) + 1 获取1-100的整数
使用random类
Random random = new Random();
int a = random.nextInt(); 获取一个随机整数
int a = random.nextInt(100) + 1 获取1-100的整数
int a = random.nextDouble(); 获取一个[0,1.0)随机浮点数
int b = random.nextBoolean(); 获取随机boolean数据
3.format格式化
String s = String.format("%.2f",3.12334) // 格式化数据
String s = String.format("%-2d",3) // 格式化数据, 右侧不足加空格
String s = String.format("%2d",3) // 格式化数据, 左侧不足加空格
String s = String.format("%02d",3) // 格式化数据, 左侧不足加0
String s = String.format("%2$.3f , %$1d, %3$d ",1,2,3) // 不按顺序输出
String s = String.format("%d %%",3) // 格式化输出"%"号
String s = String.format("%+d",3) // 格式化输出"+"号，正整数
String s = String.format("%,d",3) // 格式化输出","号，千分位
4.StringTokenizer类
本质上就是 s.split('xx') 的分割功能
StringToKenizer st1 = new StringTokenizer("you,i,he",",")
// 结果计数
int len = st1.countTokens();
// 输出遍历
while(st1.hasMoreTOkens()){
String item = st1.nextToken();
double price = double.parseDouble(item);
sum = sum + price
}
5.Scanner类
转换字符串格式
Scanner scanner = new Scanner('Hello,world')
// 1.分隔功能
scanner.useDelimiter('[,]')
while(scanner.hasnext()){
x = scanner.nextInt();
}
// 2.接收控制台输入的字符串
Scanner scanner = new Scanner(System.in)
try{
int a = scanner.nextInt();
}catch(InputMismatchException e){
System.out.print(e)
}
6.StringBuffer类
解决字符串对象，不能被修改，删除的问题。 其实使用字符串也能切割。
// 1.初始化对象
StringBuffer st = new StringBuffer("hello world")
StringBuffer st = new StringBuffer();
StringBuffer st = new StringBuffer(10);
// 2.常用方法
st.append('new student') // 追加字符串
st.append(123) // 追加整型的字符串
char c = st.charAt(0) // 获取指定位置的字符
st.setCharAt(0,"a") // 设置指定位置的字符
st = st.insert(1,"abc") // 在指定位置插入新数据，并返回结果
st = st.reverse() // 字符串序列反转
st = st.delete(0,3) // 删除指定区段的字符串，[start,end)
st = st.replace(0,3,"abc") // 替换指定区段的字符串
// 3.转换成字符串
String s = new String(st) // 转换成字符串对象
7.Exception异常类
// 1.异常抛出throw
public void hello thorws IOException(){
System.out.println("hello world");
if(true) throw new IOException();
}
// 2.try..catch捕获异常
try{
...
}catch(IOException e){
...
}finally{
...
}
// 3.自定义异常类, 主要是判断有些数据不符合要求，就抛出异常类，返回指定的结果
// 先定义自定义异常类
public class AEXception extends Exception{
public String warnMessage(){
return '数据不能为负数'
}
}
// 再定义抛出异常类
public class Bank{
public void income(int a,int b) throws AException{
if(a<0 && b<0){
throw new AException();
}
}
}
// 运算逻辑
Bank bank = new Bank();
try{
bank.income(-100,-100);
}catch(AException e){
System.out.print(e.warnMessage());
}finally{
System.out.print("即将退出程序！")
}
8.Class,Console类
1.Class类
类似于上转型对象
Class cs = Class.forName("Rect");
Rect rect = (Rect)cs.newInstance();
2.Console类
import java.io.Console
Console cons = System.console();
char[] password = cons.readPassword();
String s = new String(password)
3.Pattern类
import java.util.regex;
// 初始化
String input = "hello,good, morning, a good idea";
String regex = "good";
Pattern pattern = pattern.conpile(regex)
Matcher matcher = pattern.matcher(input)
// 使用方法
while(matcher.find()){ ... } // 输出结果
String s[] = matcher.group(); // 返回所有结果
boolean b = matcher.lookingAt(); // 返回查询的结果
boolean b = matcher.find(1); // 返回指定索引下的结果
String s = matcher.replaceFirst(","); // 替换匹配的结果
10.文件类型
1.File文件类
File f = new File("C:\\abc","hello.java");
// 普通方法
String name = f.getName() 文件名称
boolean b = f.canRead() 是否可读
boolean b = f.canWrite() 是否可写
boolean b = f.exists() 是否存在
int len = f.length() 文件的长度（单位字节）
String a = f.getAbsolutePath() 获取绝对路径
String a = f.getParent() 获取文件的父目录
boolean b = f.isFile() 是否是文件
boolean b = f.isDirectory() 是否是目录
boolean b = f.isHidden() 是否隐藏
long l = f.lastModified() 文件的上一次修改时间
// 高级方法
try{ .... }catch(IOException e){ ... } 读写文件的异常捕获
f.createNewFile(); 创建文件
f.delete(); 删除当前文件
f.mkdir(); 创建文件夹
String a[] = f.list() 返回目录下的所有文件
File a[] = f.listFiles() 返回File类型的所有文件
// 特殊方法
FileAccept fa = new FileAccept();
fa.setExtendName("java")
String a[] = f.list(fa) 返回目录下的所有文件
File a[] = f.listFiles(fa) 返回File类型的所有文件
创建FilenameFilter接口类
public class FileAccept implements FilenameFilter{
private String extendName;
public void setExtendName(String s){
extendName = "."+s;
}
// 重写接口方法
public boolean accept(File dir,String name){
return name.endsWith(extendName);
}
}
2.字节输入,输出流
1.字节输入流
// 创建字节流对象
// 方法一：
FileInputStream in = new FileInputStream("xxxx.txt"); // 创建指向文件的输入流
// 方法二：
File f = new File("xxx.txt"); // 指向输入流的源
FileInputStream in = new FileInputStream(f); // 创建指向源的输入流
// 读取文件
byte a[] = new byte[100];
int n = -1;
while((n=in.read(a,0,100))!= -1){
String s = new String(a,0,n);
}
in.close(); // 如果不关闭，可能会出现文件被占用的情况
2.字节输出流
// 创建字节流对象（直接写入）
// 方法一：
FileOutputStream out = new FileOutputStream("xxxx.txt"); // 创建指向文件的输入流
// 方法二：
File f = new File("xxx.txt"); // 指向输入流的源
FileOutputStream out = new FileOutputStream(f); // 创建指向源的输入流
// 创建字节流对象（追加写入）
// 方法一：
FileOutputStream out = new FileOutputStream("xxxx.txt",true); // 创建指向文件的输入流
// 方法二：
File f = new File("xxx.txt"); // 指向输入流的源
FileOutputStream out = new FileOutputStream(f,true); // 创建指向源的输入流
// 写入文件
String a = new String("非常不错！")
byte b[] = a.getBytes();
out.write(b); // 写入文件
out.write(b,0,b.length); // 写入文件
out.close(); // 如果不关闭，可能会出现文件被占用的情况
3.字符输入,输出流
1.字符输入流
// 创建对象
File f = new File("xxx.txt")
Reader in = new FileReader(f); // 类的上转型对象， Reader是FileReader的父类
FileReader in = new FileReader(f);
// 读取文件
int n = -1
char c[] = new char[20];
while((n=in.read(c))!=-1){
String s = new String(c,0,n);
}
in.close();
2.字符输出流
// 创建对象
File f = new File("xxx.txt")
Writer out = new FileWriter(f);// 类的上转型对象， Writer是FileWriter的父类
FileWriter out = new FileWriter(f);
// 写入文件
String s = new String("非常不错")
char c[] = s.toCharArray();
out.write(c,0,c.length);
out.flush(); // 清空当前的缓冲区
out.close();
4.缓冲输入,输出流
主要是可以按行读取文件数据
1.缓冲输入流
// 创建对象
File f = new File("xxx.txt")
FileReader in = new FileReader(f);
BufferedReader bin = new BufferedReader(in); // 上层流
// 读取文件
String str=null;
while((str=bin.readLine())!=-1){
String s = str;
}
bin.close();
2.缓冲输出流
// 创建对象
File f = new File("xxx.txt")
FileWriter out = new FileWriter(f);
BufferedWriter bout = new BufferedWriter(out); // 上层流
// 写入文件
String s = new String("非常不错")
bout.write(s);
bout.newLine(); // 添加换行
bout.flush(); // 清空当前的缓冲区
bout.close();
5.数据输入,输出流
主要是和字符输入，输出流的功能类似
1.数据输入流
// 创建对象
File f = new File("xxx.txt");
FileInputStream fo= new FileInputStream(f);
DataInputStream id = new DataInputStream(fo);
// 读取数据
int a = od.readInt();
double d = od.readDouble();
char c = '\0';
while((c=id.readChar())!='\0'){
String s = c;
}
// 读取一个UTF字符串
String s = id.readUTF();
2.数据输出流
// 创建对象
File f = new File("xxx.txt");
FileOutputStream fo= new FileOutputStream(f);
DataOutputStream od = new DataOutputStream(fo);
// 写入数据
od.writeInt(100);
od.writeDouble(3.1);
String s = new String("非常不错");
od.writeChars(s);
// 写入一个UTF字符串
od.writeUTF(s);
6.对象输入,输出流
主要是保存对象数据
1.对象输入流
// 创建对象
File f = new File("xxx.txt");
FileInputStream fo= new FileInputStream(f);
ObjectInputStream id = new ObjectInputStream(fo);
// 读取数据
TV xinfei = (TV)id.readObject();
id.close();
2.对象输出流
// 创建对象
File f = new File("xxx.txt");
FileOutputStream fo= new FileOutputStream(f);
ObjectOutputStream od = new ObjectOutputStream(fo);
// 写入数据
TV changhong = new TV();
od.writeObject(changhong);
od.close();
7.其它文件流
1.随机流
RandomAccessFile rout = new RandomAccessFile("xxx.txt",'rw');
int data[] = {1,2,3,4}
// 写入数据
for(int i=0;i<data.length;i++){
rout.writeInt(data[i]); // 写入一个整型
rout.writeUTF(str); // 写入一个UTF的字符串
}
// 读取数据
for(int i=data.length-1;i>=0;i--){
rout.seek(i*4); // int占4个字节，将文件移到指定位置
int a = rout.readInt();
String s = rout.readUTF(); // 读取一个UTF的字符串
}
// 其它读取方法
long position = 0;
rout.seek(0);
while(position<rout.length){
String s = rout.readLine(); // 读取含有汉字的文件
byte b[] = str.getBytes(iso-8859-1"")
String s1 = new String(b);
position = rout.getFilePointer(); // 获取当前读取的位置
}
rout.close();
2.数组流
ByteArrayOutputStream ob = new ByteArrayOutputStream();
String s = new String("非常不错")
byte b[] = s.getBytes();
ob.write(b);
ByteArrayInputStream ib = new ByteArrayInputStream(ob.toByteArray());
byte b[] = new byte[ob.toByteArray().length];
ib.read(b);
String s = new String(b);
CharArrayWriter oc = new CharArrayWriter();
String s = new String("非常不错");
char c[]= s.toCharArray();
oc.write(c);
CharArrayReader ic = new CharArrayReader(oc.toCharArray());
char c[] = new char[oc.toCharArray().length]
cb.read(c);
String s = new String(c);
8.exec执行文件
import java.lang.Runtime
// 通过计算机上的软件启动对应的file文件
Runtime ec = Runtime.getRuntime();
File file = new File("C:\\abc","Notepad.exe");
ec.exec(file.getAbsolutePath());
9.字符加密模块
EneryptAndDecrypt.java
pubIic class EncryptAndDecrypt{
string encrypt (String sourceString, String password) (//加密算法，
char []p= password.
int n = p.length;
char c[] = sourcesString.toCharArray();
int m= c.length;
for(int k=O;k<m;k++){
int mima = c[k]+p[k%n]; //加密
c[k] = (char)mima;
}
return new String(c); // 返回密文
}
String decrypt (String sourceString, String password) { //解密算法
char p[]= password.toCharArray();
int n = p.length;
char[] C = sourceString.toCharArray() ;
int m = c.length;
for(int k=0;k<m;k++) {
int mima = c[k]-p[k%n] ; //解密
c[k] = (char)mima;
}
return new String(c); //返回明文
}
}
11.数据库类型
1.安装JDBC驱动
1.启动mysql
1.Mysql 5.7版本可能需要初始化
在 Mysql安装目录/bin 输入以下命令
命令：mysqld --initialize-insecure
命令：mysqld
2.打开数据库
命令：mysql -u root -p
2.下载mysql JDBC
1.下载mysql数据驱动
下载 mysql-connector-java.jar 驱动包放在 jdk安装目录
C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\mysql-connector-java.jar
C:\Program Files\Java\jre1.8.0_131\lib\ext\mysql-connector-java.jar
2.启动数据库驱动
import java.lang.*;
try{
// 加载驱动
Class.forName("com.mysql.jdbc.Driver");
String uri = "jdbc:mysql://localhost:3306/students?user=root&password=123456&useSSL=true";
// 也可以添加编码
String uri = "jdbc:mysql://localhost:3306/students?user=root&password=123456&useSSL=true&characterEncoding=utf-8&serverTimezone=UTC";
// 连接数据库
Connection con = DriverManager.getConnection(uri);
Connection con = DriverManager.getConnection(uri,user,password);
// 执行数据库操作
// ...
// 关闭数据库
con.close();
}catch(SQLException e){
...
}
3.下载sql server JDBC
1.下载sql server数据驱动
下载 sql-server-java.jar 驱动包放在 jdk安装目录
C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sql-server-java.jar
C:\Program Files\Java\jre1.8.0_131\lib\ext\sql-server-java.jar
2.启动数据库驱动
import java.lang.*;
try{
// 加载驱动
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
String uri = "jdbc:sqlserver://localhost:1433;DatabaseName=students?user=root&password=123456&useSSL=true";
// 也可以添加编码
String uri = "jdbc:sqlserver://localhost:1433;DatabaseName=students?user=root&password=123456&useSSL=true&characterEncoding=utf-8";
// 连接数据库
Connection con = DriverManager.getConnection(uri);
Connection con = DriverManager.getConnection(uri,user,password);
// 执行数据库操作
// ...
// 关闭数据库
con.close();
}catch(SQLException e){
...
}
2.数据库操作
注意：连接数据库，必须要放在try… catch进行数据捕获
import java.sql.*;
1.基础的CRUD
1.查询数据
Statement sql = con.createStatement();
Statement sql = con.createStatement(type,concurrency); // 创建sql语句对象
ResultSet rs = sql.executeQuery("select * from students"); // 执行sql语句
// (1).next方法
while(rs.next()){ // 遍历数据集
String number = rs.getString(1);
String name = rs.getString(2);
Date date = rs.getDate(3);
float height = rs.getFloat(4);
int sex = rs.getInt(5);
}
// (2).rs 游标方法
rs.last(); // 移动到最后一行
int max = rs.getRow(); // 获取行数
int a[] = new Int[2];
for(int i:a){
rs.absolute(i); // 移动游标
String number = rs.getString(1);
String name = rs.getString(2);
Date date = rs.getDate(3);
float height = rs.getFloat(4);
int sex = rs.getInt(5);
}
// 执行方法
rs.first() // 游标移动到第一行
rs.privious() // 游标移动到上一行
rs.last() // 游标移动到最后一行
rs.isFirst() // 是否游标在第一行
rs.isLast(); // 是否游标在最后一行
rs.absolute(-1); // 移动到最后一行
// type的值
ResultSet.TYPE_FORWORD_ONLY 游标只能向下滚动
ResultSet.TYPE_SCROLL_INSENSITIVE 数据集不同步改变
ResultSet.TYPE_SCROLL_SENSITIVE 数据集同步改变(建议)
// concurrency的值
ResultSet.CONCUR_READ_ONLY 不能根据结果的数据集去更新数据库表
ResultSet.CONCUR_UPDATABLE 可以用数据集更新数据库的表
// 2.添加数据
String sqlStr = "insert into mess values("a","小明")" // 添加单条数据
String sqlStr = "insert into mess values("a","小明"),("b","小红")" // 添加多条数据
// 3.修改数据（比较特殊）
其它的都一样，只是使用以下方法执行sql命令，进行数据的更新。
String sqlStr = 'update mess set name="小红" where name = "小明" ' // 修改数据
sql.executeUpdate(sqlStr);
// 4.删除数据
String sqlStr = 'delete from mess where name = "小明" ' // 删除数据
2.高级操作
// 1.预处理语句
// （1.执行插入操作
String sqlStr = "insert into mess values(?,?)";
PrepareStatement preSql = con.prepareStatement(sqlStr);
preSql.setString(1,"a")
preSql.setString(2,"小明")
preSql.executeUpdate();
// （2.执行查询操作
String sqlStr = "select * from mess where name = ?";
PrepareStatement preSql = con.prepareStatement(sqlStr);
preSql.setString(1,"小明")
rs = preSql.executeQuery();
// 2.处理数据集
ResultSetMetaData metaData = rs.getMetaData(); // 获取数据集对象
int columnCount = metaData.getColumnCount(); // 获取数据集的列长
String columnName[] = new String[columnCount];
for(int i=0;i<columnCount;i++){ // 获取数据集的所有列
columnName[i] = metaData.getColumnName(i);
}
rs.last(); // 获取最后一行数据
int recordAmount = rs.getRow(); // 获取所有行
String record[][] = new String[recordAmount][columnCount]
int i=0;
rs.beforeFirst(); // 移动到开头
while(rs.next()){
for(int j=1;j<=columnCount;j++){ // 保存所有的行列数据，并返回给数组。
record[i][j] = rs.getString(j);
}
i++;
}
// 3.事务的处理
try{
con.setAutoCommit(false); // 打开数据库后，先关闭自动提交的功能
Statement sql = con.createStatement(); // 创建sql对象
String sqlStr = 'insert into mess values("a","小明")' // 添加数据
sql.executeQuery(sqlStr);
String sqlStr = 'delete from mess where name = "小明" ' // 删除数据
sql.executeQuery(sqlStr);
con.commit(); // 提交事务
con.setAutoCommit(true); // 进行提交
}catch(SQLException e){
try{
con.rollback(); // 回滚，撤销事务的操作。
}catch(SQLException e){
// ....
}
}
3.日期格式的sql语句
sql = "select * form mess where year(birthday)<1990 and month(birthday) <= 10";
sql = "select * form mess where year(birthday)<1990 between 1983 and 1988 ";
12.泛型的使用
1.泛型类
泛型类的实体和普通类的类体完全类似，由成员变量和方法构成。不关心具体数据，只关心操作的方法。
比如，设计一个锥，只关心它的底面积是多少，并不关心底的具体形状，它关心的是用底面积和高计算出自身的体积。
1.自定义泛型类
1.Cone泛型类
public class Cone<E>{
double height;
E bottom;
public Cone(E b){
bottom b;
}
public void setHeight(double h){
height = h;
}
public double computeVolume(){
String s = bottom.toString(); // 泛型变量只能调用从Object类继承的或重写的方法
double area = Double.parseDouble(s);
return 1.0/3.0*area*height;
}
}
2.Circle类
public class Circle{
double area,radius;
Circle(double r){
radius = r;
}
public String toString(){
area = radius * radius * Math.PI;
return ""+area;
}
}
3.主入口类
Circle circle = new Circle(10);
Cone<Circle> conOne = new Cone<Circle>(circle);
conOne.setHeight(16);
double d = conOne.computerVolume();
2.链表泛型类
import java.util. *;
class Student implements Comparable{
int height=0;
String name;
Student (String n, int h){
name=n;
height = h;
}
public int compareTo(Object b) { //两个 Student对象相等当且仅当两者的
//height值相等
Student st= (Student)b;
return (this.height-st.height);
}
}
public class Example15_ 4{
public static void main(String args[]){
List<Student> list = new LinkedList<Student>();
list.add(new Student ("张三”，188)) ;
list.add(new Student ("李四”，178));
list.add(new Student ("周五"，198)) ;
Iterator<Student> iter=list.iterator () ;
System.out.println("排序前，链表中的数据");
while(iter.hasNext()) {
Student stu=iter.next() ;
System.out.println(stu.name+ "身高:"+stu.height) ;
}
Collections.sort(list) ;
System.out.println("排序后，链表中的数据");
iter=list.iterator() ;
while(iter.hasNext()) {
Student stu = iter.next();
System.out.println(stu.name+ "身高:"+stu.height);
Student zhaoLin = new Student ("zhao xiao lin",178) ;
int index = Collections.binarySearch (list, zhaoLin,null)
if (index>=0) {
System.out.println (zhaoLin.name+"和链表中"+list.get(index).name+"(身高相同");
}
}
}
}
3.堆栈泛型类
Stack<Integer> stack = new Stack<Integer>();
stack.push(new Integer(1));
stack.push(new Integer(1));
int k = -1;
while(k<=10){
for(int i=1;i<=2;i++){
Integer F1 = stack.pop();
int f1 = F1.intValue();
Integer F2 = stack.pop();
int f2 = F2.intValue();
Integer temp = new Integer(f1+f2);
stack.push(temp);
stack.push(F2);
k++;
}
}
2.List集合
List<String> likes => 字符串集合 ["a","b"]
List<User> likes => POJO对象集合 [{"name":"a"},{"name":"b"}]
List<User> userList = new ArrayList<>(); // 创建对象集合
userList.add(user1); // 向集合中添加对象
userList.add(user2);
User obj = userlist.get(0) // 获取集合的数据
User obj = userlist.get(2)
int len = userlist.size() // 获取集合的长度
3.Map结构
Map<String,Object> map = new HashMap<>();
map.put("msg", "ok"); // 添加数据
map.put("data", data);
String a = map["msg"] // 获取数据
3658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
