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"] // 获取数据