JAVA基础---知识积累

最新推荐文章于 2024-08-03 13:39:46 发布

dxsksk

最新推荐文章于 2024-08-03 13:39:46 发布

阅读量79

点赞数

分类专栏： J2SE 文章标签： Java 正则表达式虚拟机 JNI FP

J2SE 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一，transient

在序列化（ObjectInputStream）时就是可以将对象序列化进物理空间上，在这个类中若设有transient的变量，序列化时不被存储，对象还原时，也不会有这个变量（作用是安全问题，有些不希望把类里面所有的东西都能存储）。

transient int a;

二，volatile:

　Java 语言中 volatile 变量可以被看作是一种 “程度较轻 synchronized”；与 synchronized 块相比，volatile 变量所需编码较少，并且运行时开销也较少，但是它所能实现功能也仅是 synchronized 一部分,在多个线程共享这个变量时，能获取到最新的修改值。

valatile int a;

三,strictfp:

strictfp修饰类或方法，可以确保浮点运算（以及所有切断）正如早期的Java版本那样准确。切断只影响某些操作的指数。当一个类被strictfp修饰，所有的方法自动被strictfp修饰。
strictfp的意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。
你可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字，例如下面的代码：

1. 合法的使用关键字strictfp

strictfp interface A {}
public strictfp class FpDemo1 {
strictfp void f() {}
}

2. 错误的使用方法

interface A {
strictfp void f();
}
public class FpDemo2 {
strictfp FpDemo2() {}
}

一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内所有浮点运算都是精确的，符合IEEE-754规范的。例如一个类被声明为strictfp，那么该类中所有的方法都是strictfp的。
四,Native

Java不是完美的，Java的不足除了体现在运行速度上要比传统的C++慢许多之外，Java无法直接访问到操作系统底层（如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。

可以将native方法比作Java程序同Ｃ程序的接口，其实现步骤：

１、在Java中声明native()方法，然后编译；

２、用javah产生一个.h文件；

３、写一个.cpp文件实现native导出方法，其中需要包含第二步产生的.h文件（注意其中又包含了JDK带的jni.h文件）；

４、将第三步的.cpp文件编译成动态链接库文件；

５、在Java中用System.loadLibrary()方法加载第四步产生的动态链接库文件，这个native()方法就可以在Java中被访问了。

五,java.lang.ref(引用)

Java中有四种类型的引用,按照强弱关系依次为:Strong Reference>SoftReference>WeakReference> PhantomReference

1，强引用（Strong Reference）：用new创建的对象，只有在没有句柄指向该对象时，内存回收时，才进行回收

2，软引用（SoftReference）：保证在虚拟机抛出 OutOfMemoryError 之前已经被清除

直要到 JVM 内存不足时且没有 Direct Reference 时才会清除，SoftReference 是用来设计 object-cache 之的。 SoftReference 不但可以把对象 cache 起来，也不会造成内存不足的错误（OutOfMemoryError）

此类的直接实例可用于实现简单缓存；该类或其派生的子类还可用于更大型的数据结构，以实现更复杂的缓存。只要软引用的指示对象是强可到达对象，即正在实际使用的对象，就不会清除软引用。例如，通过保持最近使用的项的强指示对象，并由垃圾回收器决定是否放弃剩余的项，复杂的缓存可以防止放弃最近使用的项。

3，弱引用（WeakReference）：在垃圾回收时，对其进行回收

WeakHashMap：WeakHashMap 中的每个键对象间接地存储为一个弱引用的指示对象。因此，不管是在映射内还是在映射之外，只有在垃圾回收器清除某个键的弱引用之后，该键才会自动移除。

4，虚引用（PhantomReference）：

与软引用和弱引用不同，虚引用在加入队列时并没有通过垃圾回收器自动清除。通过虚引用可到达的对象将仍然保持原状，直到所有这类引用都被清除，或者它们都变得不可到达。

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;

class MyObject {  
    private String id;  
  
    public MyObject(String id) {  
        this.id = id;  
    }  
  
    public String toString() {  
        return id;  
    }  
  
    protected void finalize() {  
        System.out.println("回收对象：" + id);  
    }  
}  
  
public class TestReferences {  
    public static void main(String[] args) {  
        // 创建强引用  
        MyObject ref = new MyObject("Hard");  
        System.out.println(ref);  
        ref = null;  
        System.gc();  
        System.out.println(ref);  
        System.out.println("------------------------------------------------------");
  
        // 创建软引用  ，只有在内存不够时才回收
        SoftReference<MyObject> softRef = new SoftReference<MyObject>(  
                new MyObject("SoftReference MyObject"));  
        System.out.println(softRef.get());  
        System.gc();  
        System.out.println(softRef.get());  
        System.out.println("------------------------------------------------------");
  
        // 创建弱引用  ,垃圾回收时，一定会被回收
        WeakReference<MyObject> weakRef = new WeakReference<MyObject>(  
                new MyObject("WeakReference MyObject"));  
        System.out.println("before gc —— " + weakRef.get());  
        System.gc();  
        System.out.println("after gc —— " + weakRef.get());  
        System.out.println("------------------------------------------------------");
  
        // 创建虚引用  
        ReferenceQueue<MyObject> rq = new ReferenceQueue<MyObject>();  
        PhantomReference<MyObject> phantomRef = new PhantomReference<MyObject>(  
                new MyObject("ReferenceQueue MyObject"), rq);  
        System.out.println("before gc —— " + phantomRef.get());  
        System.gc();  
        System.out.println("after gc —— " + phantomRef.get());  
    }  
}

Hard

null

------------------------------------------------------

回收对象：Hard----》这个表明，system.gc垃圾回收没有直接回收，而是加大权重

SoftReference MyObject

------------------------------------------------------

before gc —— WeakReference MyObject

回收对象：WeakReference MyObject

after gc —— null

------------------------------------------------------

before gc —— null

回收对象：ReferenceQueue MyObject

after gc —— null

六，正则表达式

//以下了解group与find的区别。。。

.*,[\\s\\S],[\\w\\W]等代表任意字符

 
String typeregex="\\s*(\\w+)\\s+[\\s\\S]*from\\s+(\\w+)[\\s\\S]*";
//截取select语句
Pattern pattern = Pattern.compile(typeregex, Pattern.CASE_INSENSITIVE);//提供了不区分大小写,或其他的忽略行等...模式
Matcher m = pattern.matcher(resolvedSQL);
if (m.groupCount() > 0) {
	while (m.find()) {//这个是去匹配sql时,出现了几对像以上一样的模式
		list.add(m.group(2) + "|" + m.group(1));
    //这里的group(1|2)是与以上的括号相对应的,可以指定
   }
}

String typeregex="\\s+join\\s+(\\w+)\\s+";

String resolvedSQL="select d.fguid,b.fguid from D_HR_QXSQQX as d left join d_hr_remove as b on d.fguid=b.fguid left join D_HR_QXSQQX as ss on ";
//如以上所示,这个是用来查找所有join后面的表名称,当要匹配中查找出多种情况时,不能用.*,[\\w\\W]*等,因为这样的话,只能匹配出最后一个
如String typeregex=".*\\s+join\\s+(\\w+)\\s+";

七,实现List1与List2间的拷贝

1, list1.addAll(list2)进行拷贝

2,在使用Collections.copy(destList,srcList)时,要注意destList一定要实例化好空间给他,

	
List<String> list1=new ArrayList<String>();
list1.add("mm");
List<String> list2=new ArrayList<String>(Arrays.asList(new String[10]));//实例化空间,因为刚创建时,打印getSize()为0
Collections.copy(list2, list1);

八，检查异常(Exception)与非检查异常（RuntimeException）

检查异常：当使用api的程序员能够恢复错误时，用这种异常捕获

如：数据库的连接操作--用户名，密码等由用户输入，用检查异常让使用者程序员自忆处理，自己捕获，并能自己恢复修改

非检查异常：一般前提是 使用者程序员的违例操作，如使用者传进来的对象是一个空指针，程序立即中断不会往下执行，执行下去没有意思，所以称为运行时异常

九，乱码问题，在对流进行操作时，出现了乱码问题

			InputStreamReader inputStreamReader = new InputStreamReader(
					new FileInputStream(schedulerIndexFile), "UTF-8");
			BufferedReader reader = new BufferedReader(inputStreamReader);
			StringBuffer stringBuffer = new StringBuffer();
			String s = null;
			while ((s = reader.readLine()) != null) {
				stringBuffer.append(s);
				stringBuffer.append('\n');
			}
			String tempString = stringBuffer.toString();
			tempString = tempString.replaceAll("xmlns=\"\"", "");
			OutputStreamWriter outputStreamWriter = new OutputStreamWriter(
					new FileOutputStream(schedulerIndexFile), "UTF-8");
			BufferedWriter writer = new BufferedWriter(outputStreamWriter);
			writer.write(tempString);
			writer.flush();
			writer.close();
			reader.close();

十，JVM内存设置

java -Xmx4096 -version

java -Xmx 4095 -version

dxsksk

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础---知识积累

一，transient 在序列化（ObjectInputStream）时就是可以将对象序列化进物理空间上，在这个类中若设有transient的变量，序列化时不被存储，对象还原时，也不会有这个变量（作用是安全问题，有些不希望把类里面所有的东西都能存储）。 transient int a; 二，volatile:　Java 语言中 volatile 变量可以被看作是一种 “...
复制链接

扫一扫

专栏目录