文章目录
- 1. Java有那些基本数据类型,String是不是基本数据类型,他们有何区别。
- 2. Java中char是一个基本类型,而String是一个引用类型。有时候我们需要在String 与 char 之间互相转换。
- 3. 字符串的操作:
- 4. 数据类型之间的转换
- 5. 日期和时间
- 6. 数组和集合
- 7. 文件和目录(I/O)操作
- 8. Java多态的实现(继承、重载、覆盖)
- 9. 编码转换,怎样实现将GB2312编码的字符串转换为ISO-8859-1编码的字符串。
- 10. Java中访问数据库的步骤,Statement和PreparedStatement之间的区别。
- 11. Statement 和PreparedStatement 之间的区别:
- 12. Java语言支持一些特殊的转义字符序列
- 13. 访问修饰符和非访问修饰符
1. Java有那些基本数据类型,String是不是基本数据类型,他们有何区别。
1.1 Java语言提供了八种基本类型:
六种数字类型(四个整数型,两个浮点型)
- byte 8位 字节型
- short 16位 短整型
- int 32位 整型
- long 64位 长整型
- float 32位 单精度
- double 64位 双精度
一种字符类型
- char 8位 字符型
一种布尔型
- boolean 8位 布尔型(可存储"True"和"false")
2. Java中char是一个基本类型,而String是一个引用类型。有时候我们需要在String 与 char 之间互相转换。
String 转为 char
- 使用 String.charAt( index ) 方法,返回在index位置的char字符。(返回值:char )
- 使用 String.toCharArray( ) 方法,将String 转化为 字符串数组。(返回值:char[] )
char 转为 String
- 1.效率最高的一种方法 String s = String.valueOf(‘c’)
- 2.将字符串数组转化为字符串 String s = String.valueOf(new char[] {‘G’,‘e’,‘o’,‘o’,‘o’})
- 3.用 Character 的 toString(char) 方法 ==> 实际上还是调用了String.valueOf(char)
String s = Character.toString(‘c’)- 4.new 一个 Character 调用 toString()
String s = new Character(‘c’).toString()- 5.直接用空String 拼接 ‘c’ String s = “” + ‘c’
第5种方法效率最低,因为String类是 final 属性// “” + ‘c’ 时候需要创建新的 String 类 ,如果进行很多次拼接则要创建很多个类虚拟机栈可能会溢出
3. 字符串的操作:
写一个方法,实现字符串的反转,如:输入abc,输出cba
public static String ReverseString(String s){ // 方法一
StringBuffer ls = new StringBuffer(s);
return ls.reverse().toString();
}
public static String ReverseString2(String s){ // 方法二
char temp ;
char[] ls = s.toCharArray();
for(int i = 0;i < ls.length/2;i++){
temp = ls[i];
ls[i] = ls[ls.length-1-i];
ls[ls.length-1-i] = temp;
}
String mstr = String.valueOf(ls); //String mstr = new String(ls);
return mstr;
//return ls.toString();
}
写一个方法,实现字符串的替换
public static String ReplaceString(String s){
StringBuffer ls = new StringBuffer(s);
return ls.replace(5,6,"123").toString();
}
4. 数据类型之间的转换
如何将数值型字符转换为数字(Integer,Double)
如何将数字转换为字符
如何取小数点前两位,并四舍五入。
我们还经常用到两种类变量,即String和Date。
数据类型转换的种类 java数据类型的转换一般分三种,分别是:
(1). 简单数据类型之间的转换
(2). 字符串与其它数据类型的转换
(3). 其它实用数据类型转换。
4.1 简单数据类型之间的转换
在Java中整型、实型、字符型被视为简单数据类型,这些类型由低级到高级分别为
(byte,short,char)➡int➡long➡float➡double
简单数据类型之间的转换又可以分为:
- 低级到高级的自动类型转换
- 高级到低级的强制类型转换
- 包装类过渡类型能够转换
4.2 自动类型转换
低级变量可以直接转换为高级变量为自动类型转换,例如,下面的语句可以在Java中直接通过:
byte b;
int i=b;
long l=b;
float f=b;
double d=b;
如果低级类型为char型,向高级类型(整型)转换时,会转换为对应ASCII码值,例如
char c=''c'';
int i=c;
System.out.println("output:" i);
//输出:output: 99;
对于byte,short,char三种类型而言,他们是平级的,因此不能相互自动转换,可以 使用下述的强制类型转换。
short i = 99;
char c = (char)i;
System.out.println("output:" c);
输出:output:c;
byte,short,int三种类型都是整型,因此如果操作整型数据时,最好统一使用int型。
4.3 强制类型转换
将高级变量转换为低级变量时,情况会复杂一些,你可以使用强制类型转换。即你必须采用下面这种语句格式:
int i=99;
byte b=(byte)i;
char c=(char)i;
float f=(float)i;
可以想象,这种转换肯定可能会导致溢出或精度的下降,因此并不推荐使用这种转换。
4.4 包装类过渡类型转换
在我们讨论其它变量类型之间的相互转换时,我们需要了解一下Java的包装类,所谓包装类,就是可以直接将简单类型的
变量表示为一个类,在执行变量类型的相互转换时,我们会大量使用这些包装类。Java共有六个包装类,分别是Boolean、Character、Integer、
Long、Float和 Double,从字面上我们就可以看出它们分别对应于 boolean、char、int、long、float和double。而String和Date本身就是类。所
以也就不存在什么包装类的概念了。 在进行简单数据类型之间的转换(自动转换或强制转换)时,我们总是可以利用包装类进行中间过渡。 一般
情况下,我们首先声明一个变量,然后生成一个对应的包装类,就可以利用包装类的各种方法进行类型转换了。例如:
例1,当希望把float型转 换为double型时:
float f1=100.00f;
Float F1=new float(f1);
Double d1=F1.doubleValue(); //F1.doubleValue()为Float类的返回double值 型的方法
当希望把double型转换为int型时:
double d1=100.00;
Double D1=new Double(d1);
int i1=D1.intValue();
当希望把int型转换为 double型时,
自动转换:
int i1=200;
double d1=i1;
简单类型的变量转换为相应的包装类,可以利用包装类的构造函数。即:
Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value) 而在各个包装类中,总有形为××Value()的方法,来得到其对应的简单类型数据。利用这种方法,也可以实现不同数值型变量间的转换,例如,对 于一个双精度实型类,intValue()可以得到其对应的整型变量,而doubleValue()可以得到其对应的双精度实型变量。
3 字符串型与其它数据类型
的转换 通过查阅类库中各个类提供的成员方法可以看到,几乎从java.lang.Object类派生的所有类提供了toString()方法,即将该类转换为字符
串。例如:Characrer,Integer,Float,Double,Boolean,Short等类的toString()方法 toString()方法用于将字符、整数、浮点数、双精度数、逻
辑数、短整型等类转换为字符串。如下所示:
int i1=10;
float f1=3.14f;
double d1=3.1415926;
Integer I1=new Integer(i1); //生成
Integer类
Float F1=new Float(f1); //生成Float类
Double D1=new Double(d1); //生成Double类//分别调用包装类的toString()方法转换
为字符串
String si1=I1.toString();
String sf1=F1.toString();
String sd1=D1.toString();
System.out.println("si1" si1);
System.out.println("sf1" sf1);
System.out.println("sd1" sd1);
4.4、将字符型直接做为数值转换为其它数据类型 将字符型变量转换为数值型变量实际上有两种对应关系,在我们在第一部分所说的那种转换中,实 际上是将其转换成对应的ASCII码,但是我们有时还需要另一种转换关系,例如,'‘1’'就是指的数值1,而不是其ASCII码,对于这种转换,我们可以使用Character的getNumericValue (char ch)方法。
4.5、Date类与其它数据类型的相互转换 整型和Date类之间并不存在直接的对应关系,只是你可以使用int型为分别表示年、月、日、时、分、秒
,这样就在两者之间建立了一个对应关系,在作这种转换时,你可以使用Date类构造函数的三种形式: Date(int year, int month, int date):以int型表示年、月、日 Date(int year, int month, int date, int hrs, int min):以int型表示年、月、日、时、分 Date(int year,
int month, int date, int hrs, int min, int sec):以int型表示年、月、日、时、分、秒r 在长整型和Date类之间有一个很有趣的对应关系 ,就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系,Date类也有其相应的构造函数:Date(long
date) 获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、 getHours()、
getMinutes()、getSeconds()、getDay()方法,你也可以将其理解为将Date类转换成int。而Date类的getTime()方法可以得到我们前面所说的一个
时间对应的长整型数,与包装类一样,Date类也有一个toString()方法可以将其转换为String类。有时我们希望得到Date的特定格式,例如
20020324,我们可以使用以下方法,首先在文件开始引入,
import java.text.SimpleDateFormat;
import java.util.*;
java.util.Date date = new java.util.Date();
//如果希望得到YYYYMMDD的格式
SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD");
String dateFormat=sy1.format(date);
//如果希望分开得到年,月,日
SimpleDateFormat sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date); String sday=sd.format(date);
附加: 在java中除了这些转换之外基本数据类型还可以被隐式的转换成String,例如:
System.out.print(转换 100);//如果在数据前面有字符串用 连接//就会隐式的转换成 String
1.字符型转时间型:2005-10-1
reportdate_str = "2005-10-01";
reportdate_str + reportdate_str +"00:00:00.0";
reportdate = java.sql.Timestamp.valueOf(reportdate_str);
2.时间型转字符型:
V_DATE = reportdate.toString();
3.将long型转化为String型
long APP_UNIT = (long) userview.getDEPT_ID();
String S_APP_UNIT = String.valueOf(APP_UNIT);
基本类型都可以通过String.valueOf(s)来转化为String型。
5. 日期和时间
如何取得年月日,小时分秒
Date t = new Date();
//SimpleDateFormat date1 = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");
//System.out.println(date1.format(t));
//将java.util.Date转换为java.sql.Date格式。
java.sql.Date sqld = new java.sql.Date(t.getTime());
System.out.println(sqld);
java.sql.Time sqlt = new java.sql.Time(t.getTime());
System.out.println(sqlt);
java.sql.Timestamp sqlts = new java.sql.Timestamp(t.getTime());
System.out.println(sqlts);
如何获取某个日期是当月的最后一天
/**
* 获取当月最大日期
* @return
*/
public static int daysCount(){
Calendar cal = Calendar.getInstance();
cal.set(Calendar.DATE, 1);//把日期设置为当月第一天
cal.roll(Calendar.DATE, -1);//日期回滚一天,也就是最后一天
int MaxDate=cal.get(Calendar.DATE);
System.out.println("该月最大天数:" + MaxDate + "该月最大日期:"+cal.getTime());
return MaxDate;
}
如何取得从1970年到现在的毫秒数
如何格式化日期
import java.text.SimpleDateFormat;
import java.time.Clock;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
/**
1. ClassName: DateTest <br/>
2. Description: 时间转换 与 毫秒数计算转化<br/>
3. date: 2019/12/16 18:22<br/>
4. @author sunyue <br/>
5. @since JDK 1.8
*/
public class DateTest {
public static long getSecond(Date date){
SimpleDateFormat date1 = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");
//将截取到的时间字符串转化为时间格式的字符串
Date beginTime;
try {
beginTime = date1.parse("1970-01-01 12:53:30");
} catch (Exception e) {
beginTime = null;
}
//默认为毫秒
long interval = (date.getTime()-beginTime.getTime());
return interval;
}
public static long getMS(Date date){
System.out.println("毫秒数方法一 " + Calendar.getInstance().getTimeInMillis());//方法一
System.out.println("毫秒数方法二 " + System.currentTimeMillis()); //方法二
//java8
System.out.println("毫秒数方法三(Java8)" + Clock.systemDefaultZone().millis());//方法三 java8
//怎样得到年,月,日,小时,分种,秒,毫秒数!
String Pid=(new SimpleDateFormat("yyyyMMddHHmmss", Locale.US)).format(new java.util.Date()); //上面怎样才能>求出毫秒数
Calendar cal=Calendar.getInstance();
cal.setTime(new Date());
int year=cal.get(Calendar.YEAR);
int month=cal.get(Calendar.MONTH)+1;
int date0=cal.get(Calendar.DATE);
int hour=cal.get(Calendar.HOUR);
int minute=cal.get(Calendar.MINUTE);
int second=cal.get(Calendar.SECOND);
int milliSecond=cal.get(Calendar.MILLISECOND);
return year;
}
/**
* 格式化时间
* @param date
* @return
*/
public static Date getTime(Date date){
SimpleDateFormat date1 = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");
System.out.println("格式化时间1:" + date1.format(date));
java.sql.Date sqld = new java.sql.Date(date.getTime());
System.out.println("java.sql 格式化时间Date:" + sqld);
java.sql.Time sqlt = new java.sql.Time(date.getTime());
System.out.println("java.sql 格式化时间time:" + sqlt);
java.sql.Timestamp sqlts = new java.sql.Timestamp(date.getTime());
System.out.println("java.sql 格式化时间戳:" + sqlts);
//方法二 java 8
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
LocalDate date2 = LocalDate.now();
System.out.println("java8格式化时间:"+date2.format(formatter));
//java 8 引入新的日期API 其中包括 LocalDate LocalTime LocalDateTime Clock Instant 等
// 这些类设计都使用了不变模式,所以是线程安全的
return sqlts;
}
/**
* 将毫秒数转化为xx天xx小时xx分钟xx秒形式
* @param mss
* @return 该毫秒数转换为 * days * hours * minutes * seconds 后的格式
* @author sunyue
*/
public static String formatDuring(long mss) {
long days = mss / (1000 * 60 * 60 * 24);
long hours = (mss % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60);
long minutes = (mss % (1000 * 60 * 60)) / (1000 * 60);
long seconds = (mss % (1000 * 60)) / 1000;
System.out.println( days + " 天 " + hours + " 小时 " + minutes + " 分钟 "
+ seconds + " 秒 ");
return days + " days " + hours + " hours " + minutes + " minutes "
+ seconds + " seconds ";
}
/**
* 获取当月最大日期
* @return
*/
public static int daysCount(){
Calendar cal = Calendar.getInstance();
cal.set(Calendar.DATE, 1);//把日期设置为当月第一天
cal.roll(Calendar.DATE, -1);//日期回滚一天,也就是最后一天
int MaxDate=cal.get(Calendar.DATE);
System.out.println("该月最大天数:" + MaxDate + "该月最大日期:"+cal.getTime());
return MaxDate;
}
public static void main(String args[]){
Date date = new Date();
System.out.println("时间" + getTime(date));
getSecond(date);
getMS(date);
formatDuring(getSecond(date));
daysCount();
System.out.println("-------" + getMS(date));
}
}
6. 数组和集合
数组:可以存储基本数据类型和对象,数组的长度固定,不适合在对象数量未知的情况下使用。
集合:只能存储对象,对象类型可以不一样,长度可变,可在多数情况下使用。
7. 文件和目录(I/O)操作
如何列出某个目录下的所有文件
File file=new File("H:\\");
for(File temp:file.listFiles()){//Java5的新特性之一就是增强的for循环。
//上面的for循环的意思是:定义一个File的变量temp,变量child会自动递增遍历File类型的数组listFiles
我们不再需要写得像原来那么复杂了,数组、迭代器都可以这样使用,
if(temp.isDirectory()){ System.out.println(temp.toString()); } }
如何列出某个目录下的所有子目录
判断一个文件或目录是否存在
import java.io.File;
import java.io.IOException;
/**
* ClassName: FileTest <br/>
* Description: 列出一个文件下的所有文件<br/>
* date: 2019/12/16 19:55<br/>
* @author sunyue <br/>
* @since JDK 1.8
*/
public class FileTest {
/**
* 列出文件夹下的子文件夹名
* @param localRoot
* @throws
*/
public static void list(String localRoot) {
File[] fs = new File(localRoot).listFiles();
if ((fs == null) || (fs.length <= 0)) {
System.out.println("空文件夹");
return;
}
for (File f : fs) {
if (f.isDirectory()) {
System.out.println("目录:"+ f.getName());
}
}
}
// 判断文件是否存在
public static void judeFileExists(File file) {
if (file.exists()) {
System.out.println("file exists");
} else {
System.out.println("file not exists, create it ...");
try {
file.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// 判断文件夹是否存在
public static void judeDirExists(File file) {
if (file.exists()) {
if (file.isDirectory()) {
System.out.println("dir exists");
} else {
System.out.println("the same name file exists, can not create dir");
}
} else {
System.out.println("dir not exists, create it ...");
file.mkdir();
}
}
public static void main(String args[]) {
File file1 = new File("C:\\");
for (File temp : file1.listFiles()) {
/* Java5的新特性之一就是增强的for循环。
上面的for循环的意思是:定义一个File的变量temp,变量child会自动递增遍历File类型的数组listFiles
我们不再需要写得像原来那么复杂了,数组、迭代器都可以这样使用,
*/
if (temp.isDirectory()) {
System.out.println(temp.toString());
}
}
list("C:\\");
File file = new File("c:\\test_file.txt");
FileTest.judeFileExists(file);
File dir = new File("c:\\test_dir");
FileTest.judeDirExists(dir);
}
}
如何读写文件
/**
* 写入文件
* @param path
*/
public static void WriteFile(String path){
try{
File writename = new File("c:\\input.txt"); // 相对路径,如果没有则要建立一个新的input.txt文件
writename.createNewFile(); // 创建新文件
BufferedWriter out = new BufferedWriter(new FileWriter(writename));
out.write("我会写入文件啦\r\n"); // \r\n即为换行
out.flush(); // 把缓存区内容压入文件
out.close(); // 最后记得关闭文件
System.out.println("写入成功");
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 读取文件
* @param path
*/
public static void ReadFile(String path) {
try { // 防止文件建立或读取失败,用catch捕捉错误并打印,也可以throw
File filename = new File(path); // 要读取以上路径的input.txt文件
BufferedReader in = new BufferedReader(new FileReader(filename));
String str;
while ((str = in.readLine()) != null) {
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
}
}
8. Java多态的实现(继承、重载、覆盖)
9. 编码转换,怎样实现将GB2312编码的字符串转换为ISO-8859-1编码的字符串。
String s1 = "你好";
String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");
10. Java中访问数据库的步骤,Statement和PreparedStatement之间的区别。
Java 中访问数据库的步骤
1)注册驱动;
2)建立连接;
3)创建Statement;
4)执行sql 语句;
5)处理结果集(若sql 语句为查询语句);
6)关闭连接。
11. Statement 和PreparedStatement 之间的区别:
与Statement相比:
①PreparedStatement接口代表预编译的语句,它主要的优势在于可以减少SQL的编译错误并增加SQL的安全性(减少SQL注射攻击的可能性);
②PreparedStatement中的SQL语句是可以带参数的,避免了用字符串连接拼接SQL语句的麻烦和不安全;
③当批量处理SQL或频繁执行相同的查询时,PreparedStatement有明显的性能上的优势,由于数据库可以将编译优化后的SQL语句缓 存起来,下次执行相同结构的语句时就会很快(不用再次编译和生成执行计划)。
补充:为了提供对存储过程的调用,JDBC API中还提供了CallableStatement接口。存储过程(Stored Procedure)是数据库中一组为了完成特定功能的SQL语句的集合,经编译后存储在数据库中,用户通过指定存储过程的名字并给出参数(如果该存储过 程带有参数)来执行它。虽然调用存储过程会在网络开销、安全性、性能上获得很多好处,但是存在如果底层数据库发生迁移时就会有很多麻烦,因为每种数据库的 存储过程在书写上存在不少的差别。
12. Java语言支持一些特殊的转义字符序列
符号 | 字符含义 |
---|---|
\n | 换行(0x0a) |
\r | 回车(0x0d) |
\f | 换页符(0x0c) |
\b | 退格(0x08) |
\0 | 空字符(0x20) |
\s | 字符串 |
\t | 制表符 |
\" | 双引号 |
\ ’ | 单引号 |
\\ | 反斜杠 |
\ddd | 八进制字符(ddd) |
\uxxxx | 16进制Unicode字符(xxxx) |