本文深入探讨Java中的关键概念，包括数组、位运算、JDBC、数据结构如ArrayList和LinkedList，以及Map的使用。同时，详细解析了Integer与int的区别、引用与堆栈的工作原理、异常处理、垃圾回收机制和常量池缓存机制。此外，还介绍了强制类型转换、StringBuilder的遍历、Generic泛型应用以及JDBC连接MySQL的方法。
文章目录
堆栈内存实例
public class ArrayDemo {
public static void main(String args[]) {
int data[] = null;
data = new int[3]; //开辟一个长度为3的数组
data[0] = 10;
data[1] = 20;
data[2] = 30;
}
}
public class ArrayDemo {
public static void main(String args[]) {
int data[] = null;
data = new int[3]; //开辟一个长度为3的数组
int temp[] = null; //声明对象
data[0] = 10;
data[1] = 20;
data[2] = 30;
temp = data; //int temp[] = data;
temp[0] = 99;
for(int i = 0; i < temp.length; i++) {
System.out.println(data[i]);
}
}
}
数组使用
int[] a = new int[100] //或者 int[] a = new int[n], 数组长度不要求是常量
位运算符(bit operation)
- 按位异或(^), 相同为0, 相异为1
应用场景, 场景3：有两个int类型变量x、y,要求两者数字交换，不用临时变量？
x ^= y; y ^= x; x ^= y; - 取反
int A = 60; //A=(00111100)
System.out.println( "~A=" + (~A) ); //~A = 11000011, 符号位不动, 其他取反加一
// 计算的时候, 符号位不参与计算
//~A结果为(-61)
- 无符号位右移 >>>
无符号位右移, 得到的空位用0填充, e.g. A =60=(00111100), 无符号位右移得到(00001111)
int a = 60;
System.out.println( "A>>>2=" + (A>>>2) );
-
算术右移>>
参考文献
算术右移运算符(>>)，也称带符号右移。用最高位填充移位后左侧的空位。
为何用最高位填充? 很简单, 如果是个带符号数, 最高位为1, 右移, 得到的肯定还是个负数(最高位为1), 右移一位, 相当于除2,按上一篇，-1在32位二进制中表示为： 11111111 11111111 11111111 11111111 -1>>1：按位右移，符号位不变，仍旧得到 11111111 11111111 11111111 11111111 因此值仍为-1 而-1>>>1的结果为 01111111 11111111 11111111 11111111
取反运算,
JDBC
java中 update语句
更新操作, 除了日期的增加, 其他一律用问号?, 不论是否是批量(batch)更新
String sql = "UPDATE thetry SET EndTryDate=DATE_ADD(EndTryDate, INTERVAL 1 MONTH),"
+"TryStatus=延期 WHERE id = ?"; //试用期增加一个月
不能下面这样
String sql = "UPDATE thetry SET EndTryDate=DATE_ADD(EndTryDate, INTERVAL 1 MONTH),"
+"TryStatus="延期" WHERE id = ?"; //试用期增加一个月
//报错 The operator * is undefined for the argument type(s) java.lang.String, java.lang.String
// 因为sql是String类型, 里面不能再嵌套字符串类型了, 会被当做乘号*
批量更新数据: 参考文献
//日期的可以不用问号, 其他好像必须问号, 不能直接 SET TryStatus=延期, 完全错误
String sql = "UPDATE thetry SET EndTryDate=DATE_ADD(EndTryDate, INTERVAL 1 MONTH),"
+"TryStatus=? WHERE id = ?"; //试用期增加一个月
pstmt=conn.prepareStatement(sql);
pstmt.setString(1, "延期");
pstmt.setInt(2, id);
导入包的问题
- 记住一定导入这个包, 别导入sun.List
1. Integer 与 int
- Integer 默认值为 null, 即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别
，则只能使用Integer. - 什么时候用Integer :
如果该属性所对应的数据库的字段是主键或者是外键时，用Integer；因为Integer的默认值为null，数据库的主键或者外键不能为空，但是可以为null
什么时候用int :
如果表示数量用int，因为int的默认值为0，它不能为null或者空
参考文献
2 引用与堆栈
堆栈参考文献
图解文章
下图结果为 true
【说明】
两个引用都指向了同一个对象，依据jdk的说明过程是这样的：
在栈中查找有没有存放值为"red_ant"的地址，如果没有，则开辟一个这个地址。然后hoyl对象和studio对象，都引用这个地址当然是同一个对象了。
下图结果为 false
new 相当于开辟了一个新的空间，原来的那个我不用也不认了。new几个就会形成几个，虽然内容是相同的，但是地址不一样，也不是同一个对象
下图: str1称为引用
下图， str1是一个引用， 相当于C++的指针。 str1和str2指向不同对象，说明
继承的构造器
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
public class Car extends Vehicle {
private int loader;
public Car(String brand, String color, int loader) {
super(brand, color);
// TODO Auto-generated constructor stub
this.loader = loader;
}
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
异常
try 与 catch 只能放在一个方法内部，不能直接放在class 中（面向过程的错误）
package test;
import java.io.*;
public class Test_exception {
boolean tmp = false;
//public static void main(String[] args)
//{
try {
int a[] = new int[3];
System.out.println(a[3]);
tmp = true;
}catch(ArrayIndexOutOfBoundsException e) {
System.out.println("数组越界");
}
finally {
if(tmp)
{
System.out.println("程序正常，运行结束");
}
else
{
System.out.println("程序异常，运行结束");
}
}
//}
}
正确的代码
package test;
import java.io.*;
public class Test_exception {
public static boolean tmp = false;
public static void main(String[] args)
{
try {
int a[] = new int[3];
System.out.println(a[3]);
tmp = true;
}catch(ArrayIndexOutOfBoundsException e) {
System.out.println("数组越界");
}
finally {
if(tmp)
{
System.out.println("程序正常，运行结束");
}
else
{
System.out.println("程序异常，运行结束");
}
}
}
}
垃圾回收（GC）
常量池
1. 常量池缓存机制
Byte,Short,Integer,Long,Character,Boolean
这5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，
Integer i1 = 40;
Integer i2 = 40;
System.out.println(i1==i2);//输出TRUE
参考文献
因为-128到127是byte的取值范围，如果在这个取值范围内，自动装箱就不会创建新的对象，而是从常量池中获取，超过了byte取值范围就会再创建新对象~这个就是 i1==i2 的结果为 true 的原因了
强制转化
string->int或者double
public class Test{
public static void main(String args[]){
int x =Integer.parseInt("9");
double c = Double.parseDouble("5");
int b = Integer.parseInt("444",16); //16进制
System.out.println(x); //9
System.out.println(c); //5.0
System.out.println(b); //1092
}
}
java DataStructure
all
ArrayList
package my_class;
import java.util.*;
public class Test_ArrayList {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<Student> arrList =
new ArrayList<>();
arrList.add(new Student());
arrList.add(new Student());
//方法1
Student tmp1 = arrList.get(0);
Student tmp2 = arrList.get(1);
//方法2: Iterator
Iterator ele = arrList.iterator();
while(ele.hasNext())
{
System.out.println(ele.next());
}
}
}
class Student
{
String name;
int age;
double score;
}
LinkedList
package my_class;
import java.util.LinkedList;
public class My_Queue <T> {
private LinkedList<T> que;
My_Queue() {
que = new LinkedList<>();
// TODO Auto-generated constructor stub
}
public void put(T o)
{
que.addLast(o);
}
public T get() //取出队首, 并且出队
{
T tmp = que.getFirst();
que.removeFirst();
return tmp;
}
public Boolean isEmpty()
{
return que.isEmpty();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
My_Queue<String> que_ = new My_Queue<>();
que_.put("Tom");
que_.put("Mary");
que_.put("Jame");
while(!que_.isEmpty())
{
System.out.println(que_.get());
}
}
}
Map(无序)
1. Map中的key:无序, 不可重复的, 使用Set存储所有的key
2. Map中的value:无序的, 可重复的, 使用Collection存储所有的value
遍历map
hashcode()
public class HashTest {
private int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
public int hashCode() {
return i % 10;
}
public final static void main(String[] args) {
HashTest a = new HashTest();
HashTest b = new HashTest();
a.setI(1);
b.setI(1);
Set<HashTest> set = new HashSet<HashTest>();
set.add(a);
set.add(b);
System.out.println(a.hashCode() == b.hashCode());
System.out.println(a.equals(b));
System.out.println(set);
}
}
Map<Integer, String> map = new HashMap<>();
map.put(1, "aaa");
map.put(2, "bbb");
//System.out.println(map.toString());
for(Map.Entry<Integer, String> entry : map.entrySet())
{
System.out.println(entry.getKey()+":"+entry.getValue());
}
// 上图第二题代码
package test_string;
import java.util.*;
public class Test_Map {
public static void main(String[] args) {
// TODO Auto-generated method stub
StringBuilder str = new StringBuilder("6489336837");
Map<Character, Integer> map = new HashMap<Character, Integer>();
for(int i=0; i<str.length(); i++)
{
if(!map.containsKey(str.charAt(i)))
{
map.put(str.charAt(i), 1);
}
else
{
map.put( str.charAt(i), map.get(str.charAt(i))+1 ); //map.get(key);
}
}
for(Map.Entry<Character, Integer>entry : map.entrySet())
{
System.out.print(entry.getKey()
+":"+entry.getValue()+" ");
}
}
}
import java.util.*;
public class CollectionsDemo {
public static void main(String[] args) {
Map m1 = new HashMap();
m1.put("Zara", "8"); //map加入元素, 用put
m1.put("Mahnaz", "31");
m1.put("Ayan", "12");
m1.put("Daisy", "14");
System.out.println();
System.out.println(" Map Elements");
System.out.print("\t" + m1);
}
}
下面为输出
Map Elements
{Mahnaz=31, Ayan=12, Daisy=14, Zara=8}
Generic泛化
//读取出来的东西只能存放在Fruit或它的基类里。
Fruit newFruit1=p.get();
Object newFruit2=p.get();
Apple newFruit3=p.get(); //Error
应用举例
- for map
public interface Mymap<K, V> {
public K getKey();
public V getValue();
}
public class MymapImpl<K, V> implements Mymap<K, V> {
private K key;
private V value;
public MymapImpl(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
}
下来就可以传入任意类型，创建实例了，不用转化类型
Mymap<String, Integer> mp1= new MymapImpl<String, Integer>("Even", 8);
Mymap<String, String> mp2= new MymapImpl<String, String>("hello", "world");
Mymap<Integer, Integer> mp3= new MymapImpl<Integer, Integer>(888, 888);
- 如果要定义超过两个，三个或三个以上的泛型参数可以使用T1, T2, …, Tn，像这样子
StringBuilder
遍历StringBuilder
StringBuilder str = new StringBuilder("6489336837");
for(int i=0; i<str.length(); i++)
{
System.out.println(str.charAt(i));
}
获得长度
.length()
map
获得 value
value = map.get(key); //
initialize的错误
JDBC 连接mysql
import java.sql.*;
public class Tes_mysql {
public static void main(String[] args) {
// TODO Auto-generated method stub
try{
Class.forName("com.mysql.jdbc.Driver");
Connection conn;
String url="jdbc:mysql://localhost:3306/Student?useSSL=true"; //Student为数据库名
String user="root";
String password="159753jessica";
conn=DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement();
ResultSet rs=stmt.executeQuery("SELECT * FROM student"); //student表名
while(rs.next()){
System.out.println(rs.getString("name"));
}
}catch(Exception e){
System.out.println("err="+e.getMessage());
}
}
}
Java中equals()和“==”区别
- equals()比较的是两字符串内容是否相同
- ==”比较的是存放的内存地址
参考文献
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
