java基础知识大全

最新推荐文章于 2021-01-09 16:20:53 发布
最新推荐文章于 2021-01-09 16:20:53 发布
阅读量547 收藏
点赞数
分类专栏： 4-2 java se
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzzky/article/details/44633075
版权

 
 Java快速上手
 JVM内存结构及其调优
  在Eclipse下开发Java程序
  在Linux下开发Java
   Java核心语法详解
  Java面向对象编程
  Java面向对象编程扩展
  Java编码规范与样式
 
  Java输入/输出流


  Java多线程编程

实现runnable接口：
package test;
import java.util.Date;
public class TestRunnable implements Runnable {
public int time;// 休眠时间
public String user;// 调用用户
// 构造函数
public TestRunnable(int time, String user) {
this.time = time;
this.user = user;
}
// 线程体
public void run() {
while (true) {
try {
System.out.println(user + "休息" + time + "ms - " + new Date());
Thread.sleep(time);
} catch (Exception e) {
System.out.println(e);
}
}
}
// 启动线程实例
public static void main(String args[]) {
TestRunnable thread1 = new TestRunnable(1000, "Jack");
new Thread(thread1).start();
TestRunnable thread2 = new TestRunnable(3000, "Mike");
new Thread(thread2).start();
}
}

继承Thread类
package test;
import java.util.Date;
public class TestThread extends Thread {
public int time;// 休眠时间
public String user;// 调用用户
// 构造函数
public TestThread(int time, String user) {
this.time = time;
this.user = user;
}
// 线程体
public void run() {
while (true) {
try {
System.out.println(user + "休息" + time + "ms - " + new Date());
Thread.sleep(time);
} catch (Exception e) {
System.out.println(e);
}
}
}
// 启动线程实例
public static void main(String args[]) {
TestThread thread1 = new TestThread(1000, "Jack");
//TestThread thread2 = new TestThread(3000, "Mike");
thread1.setPriority(1);
//thread2.setPriority(Thread.MAX_PRIORITY);
thread1.start();
//thread2.start();
}
}

TreadGroup
package test;
public class TestThreadGroup {
public static void main(String args[]) {
ThreadGroup group1=new ThreadGroup("group1");
ThreadGroup group2=new ThreadGroup(group1,"group2");
Thread t1 = new Thread(group1, new TestThread(1000, "AAA"));
Thread t2 = new Thread(group2, new TestThread(1000, "BBB"));
Thread t3 = new Thread(group2, new TestThread(1000, "CCC"));
t1.start();
t2.start();
t3.start();
System.out.println(group1.activeCount());
System.out.println(group2.activeCount());
System.out.println(group1.activeGroupCount());
}
}

线程池：

TimerTask：

package test;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class TestTimerTask extends TimerTask {
public void run() {
System.out.println(new Date());
}

public static void main(String[] args) {
Timer timer = new Timer();
TimerTask task = new TestTimerTask();
timer.schedule(task, 1000, 1000);
}
}

线程同步：

package test;
public class CheckInOut {
public static void main(String[] args) {
BankCard card = new BankCard();
Parent px = new Parent(card, "爸爸", 1500, 500);
Parent py = new Parent(card, "妈妈", 1000, 800);
Parent pz = new Parent(card, "爷爷", 800, 1000);
Children ca = new Children(card, "大女儿", 400, 600);
Children cb = new Children(card, "二女儿", 300, 600);
Children cc = new Children(card, "三儿子", 500, 600);
new Thread(px).start();
new Thread(py).start();
new Thread(pz).start();
new Thread(ca).start();
new Thread(cb).start();
new Thread(cc).start();
}
}
class BankCard {
int sum = 0;
// 存款
public synchronized void save(String name, int count) {
// 如果存了足够的钱就不在存了
while (sum > 5000) {
try {
System.out.println(name + "\t存款: 发现钱够了");
// 等待，并且从这里退出push()
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 注意，notifyAll()以后，并没有退出，而是继续执行直到完成。
this.sum += count;
System.out.println(name + "\t存入了 [￥" + count + "]\t余额 [￥" + this.sum + "]");

// 因为我们不确定有没有线程在wait()，所以我们既然存了钱，就唤醒有可能等待的孩子，让他们醒来，准备取款
notifyAll();
System.out.println("\t" + name + "告诉孩子存钱了");
}

// 取款
public synchronized void cost(String name, int count) {
// 如果钱不够了，就不再取款
while (sum < count) {
try {
System.out.println(name + "\t取款: 等钱花" + count);
// 等待，并且从这里退出pop()
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

// 注意，notifyAll()以后，并没有退出，而是继续执行直到完成。
this.sum -= count;
System.out.println(name + "\t取走了 [￥" + count + "]\t余额 [￥" + this.sum + "]");

// 因为我们不确定有没有线程在wait()，所以我们既然消费了产品，就唤醒有可能等待的生产者，让他们醒来，准备生产
notifyAll();
System.out.println("\t" + name + "告诉父母取钱了");
}
}
class Parent implements Runnable {
BankCard card = null;// 银行卡
String name;// 姓名
int count;// 存款数量
int interval;// 存款时间间隔
Parent(BankCard card, String name, int count, int interval) {
this.card = card;
this.name = name;
this.count = count;
this.interval = interval;
}
public void run() {
while (true) {
card.save(name, count);
try {
Thread.sleep(interval);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Children implements Runnable {
BankCard card = null;// 银行卡
String name;// 姓名
int count;// 取款数量
int interval;// 取款时间间隔
Children(BankCard card, String name, int count, int interval) {
this.card = card;
this.name = name;
this.count = count;
this.interval = interval;
}
public void run() {
while (true) {
//int count = (int) (Math.random() * degree);
card.cost(name, count);
try {
Thread.sleep(interval);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

生产者消费者模型：

package test;
public class ProducerConsumer {
public static void main(String[] args) {
ProductList ps = new ProductList();
Producer px = new Producer(ps, "生产者X");
Producer py = new Producer(ps, "生产者Y");
Consumer ca = new Consumer(ps, "消费者A");
Consumer cb = new Consumer(ps, "消费者B");
Consumer cc = new Consumer(ps, "消费者C");
new Thread(px).start();
new Thread(py).start();
new Thread(ca).start();
new Thread(cb).start();
new Thread(cc).start();
}
}


/**
* @author liuzhongbing
* 产品类
*/
class Product {
private String producedBy = "N/A";
private String consumedBy = "N/A";


// 构造函数，指明及生产者名字
Product(String producedBy) {
this.producedBy = producedBy;
}

// 消费，需要指明消费者名字
public void consume(String consumedBy) {
this.consumedBy = consumedBy;
}


public String toString() {
return "产品, 生产者 = " + producedBy + ", 消费者 = "
+ consumedBy;
}

public String getProducedBy() {
return producedBy;
}


public void setProducedBy(String producedBy) {
this.producedBy = producedBy;
}

public String getConsumedBy() {
return consumedBy;
}


public void setConsumedBy(String consumedBy) {
this.consumedBy = consumedBy;
}
}

/**
* @author liuzhongbing
* 这个class就是仓库，是生产者跟消费者共同争夺控制权的同步资源
*/
class ProductList {
int index = 0;
Product[] productList = new Product[6];


// push使用来让生产者放置产品的
public synchronized void push(Product product) {
// 如果仓库满了
while (index == productList.length) {
try {
System.out.println("  " + product.getProducedBy() + " is waiting.");
// 等待，并且从这里退出push()
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 注意，notifyAll()以后，并没有退出，而是继续执行直到完成。
productList[index] = product;
index++;
System.out.println(index + " " + product.getProducedBy() + " 生产了: " + product);

// 因为我们不确定有没有线程在wait()，所以我们既然生产了产品，就唤醒有可能等待的消费者，让他们醒来，准备消费
notifyAll();
System.out.println("  " + product.getProducedBy() + " sent a notifyAll().");
}


// pop用来让消费者取出产品的
public synchronized Product pop(String consumerName) {
// 如果仓库空了
while (index == 0) {
try {
System.out.println("  " + consumerName + " is waiting.");
// 等待，并且从这里退出pop()
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

// 注意，notifyAll()以后，并没有退出，而是继续执行直到完成。
// 取出产品
index--;
Product product = productList[index];
product.consume(consumerName);
System.out.println(index + " " + product.getConsumedBy() + " 消费了: " + product);

// 因为我们不确定有没有线程在wait()，所以我们既然消费了产品，就唤醒有可能等待的生产者，让他们醒来，准备生产
notifyAll();
System.out.println("  " + consumerName + " sent a notifyAll().");
return product;
}
}


/**
* @author liuzhongbing
* 生产者
*/
class Producer implements Runnable {


String name;
ProductList ps = null;


Producer(ProductList ps, String name) {
this.ps = ps;
this.name = name;
}


public void run() {
while (true) {
Product product = new Product(name);
ps.push(product);
try {
Thread.sleep((int) (Math.random() * 300));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}


class Consumer implements Runnable {


String name;
ProductList ps = null;


Consumer(ProductList ps, String name) {
this.ps = ps;
this.name = name;
}


public void run() {
while (true) {
ps.pop(name);
try {
Thread.sleep((int) (Math.random() * 600));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

Java常用实体类：

String相关类：

package test.String;
public class TestString {

static int count = 100;// 循环次数

// 测试String
public static void testString() {
long start = System.nanoTime();
String str = "";
for (int i = 0; i < count; i++) {
str += "," + i;
}
long end = System.nanoTime();
System.out.println("String：" + (end - start));
}


// 测试StringBuffer
public static void testStringBuffer() {
long start = System.nanoTime();
StringBuffer str = new StringBuffer();
for (int i = 0; i < count; i++) {
str.append(",").append(i);
}
long end = System.nanoTime();
System.out.println("StringBuffer：" + (end - start));
}


// 测试StringBuilder
public static void testStringBuilder() {
long start = System.nanoTime();
StringBuilder str = new StringBuilder();
for (int i = 0; i < count; i++) {
str.append(",").append(i);
}
long end = System.nanoTime();
System.out.println("StringBuilder：" + (end - start));
}


public static void main(String[] args) {
//TestString.testString();
TestString.testStringBuffer();
TestString.testStringBuilder();
}
}


日期实体类：

package test.Date;
import java.util.Date;
public class TestDate {
public static void main(String[] args) {
long cur = System.currentTimeMillis();
Date date = new Date(cur);
System.out.println(date);//Thu Mar 26 17:34:54 CST 2015
}
}

package test.Date;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDateFormat {
public static void main(String[] args) throws Exception {
Date date = new Date();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(format.format(date));

String str = "2008-08-08 08:08:08";
System.out.println(format.parse(str));
}
}

//2015-03-26 17:36:03
//Fri Aug 08 08:08:08 CST 2008


系统实体类：

数组拷贝：

package test.System;
public class TestSystemArrayCopy {
public static void main(String args[]) {
// 定义源数组
int[] a = new int[10];
for (int i = 0; i < 10; i++) {
a[i] = i+1;
}

// 拷贝目标数组
int[] b = new int[5];
System.arraycopy(a, 2, b, 1, 4);

// 输出目标数组
for (int i = 0; i < 5; i++) {
System.out.println("b" + i + "=" + b[i]);
}
}
}

系统环境变量获取

package test.System;
import java.util.Iterator;
import java.util.Map;
public class TestSystemEnv {
public static void main(String args[]) {

// 取得环境变量列表
Map<String, String> map = System.getenv();
Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
String key = it.next();// 键
String value = map.get(key);// 值
System.out.println(key + "=" + value);
}

// 取得某一个环境变量
String javahome = System.getenv("JAVA_HOME");// 取得JAVA_HOME
String path = System.getenv("PATH");// 取得PATH
String classpath = System.getenv("CLASSPATH");// 取得CLASSPATH
System.out.println("javahome=" + javahome);
System.out.println("path=" + path);
System.out.println("classpath=" + classpath);
}
}

system 退出：

package test.System;
import java.util.Iterator;
import java.util.Map;
public class TestSystemEnv {
public static void main(String args[]) {

// 取得环境变量列表
Map<String, String> map = System.getenv();
Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
String key = it.next();// 键
String value = map.get(key);// 值
System.out.println(key + "=" + value);
}

// 取得某一个环境变量
String javahome = System.getenv("JAVA_HOME");// 取得JAVA_HOME
String path = System.getenv("PATH");// 取得PATH
String classpath = System.getenv("CLASSPATH");// 取得CLASSPATH
System.out.println("javahome=" + javahome);
System.out.println("path=" + path);
System.out.println("classpath=" + classpath);
}
}

系统属性：

package test.System;

import java.util.Enumeration;
import java.util.Properties;
public class TestSystemProperty {
public static void main(String args[]) {
// 取得系统属性列表
Properties properties = System.getProperties();
Enumeration<Object> e = properties.keys();
while (e.hasMoreElements()) {
String key = (String)e.nextElement();// 键
String value = properties.getProperty(key);// 值
System.out.println(key + "=" + value);
}

// 取得某一个系统属性
String osname = System.getProperty("os.name");// 取得os.name
String osversion = System.getProperty("os.version");// 取得os.version
String javaname = System.getProperty("java.vm.name");// 取得java.vm.name
String javaversion = System.getProperty("java.version");// 取得java.version
System.out.println("操作系统名称=" + osname);
System.out.println("操作系统版本=" + osversion);
System.out.println("JVM名称=" + javaname);
System.out.println("Java版本=" + javaversion);
System.setProperty("java.version2", "aa");
System.setProperty("java.version2", "aa");
String javaversion2 = System.getProperty("java.version2");
System.out.println("Java版本=" + javaversion2);
}
}

系统时间：

 package test.System;


public class TestSystemTime {
public static void main(String args[]) {
long startMillisTime = System.currentTimeMillis();
long startNanoTime = System.nanoTime();
System.out.println("startMillisTime=" + startMillisTime);
System.out.println("startNanoTime=" + startNanoTime);


// 定义源数组
int[] a = new int[10];
for (int i = 0; i < 10; i++) {
a[i] = i+1;
}

// 拷贝目标数组
int[] b = new int[5];
System.arraycopy(a, 2, b, 1, 4);

// 输出目标数组
for (int i = 0; i < 5; i++) {
System.out.println("b" + i + "=" + b[i]);
}


long endMillisTime = System.currentTimeMillis();
long endNanoTime = System.nanoTime();
System.out.println("endMillisTime=" + endMillisTime);
System.out.println("endNanoTime=" + endNanoTime);

System.out.println("毫秒：" + (endMillisTime - startMillisTime));
System.out.println("微秒：" + (endNanoTime - startNanoTime));
}
}


程序运行时：

package test.Runtime;
public class TestRuntimeMemory {
public static void main(String[] args) {
System.out.println("内存总量：" + Runtime.getRuntime().totalMemory());
System.out.println("最大内存量：" + Runtime.getRuntime().maxMemory());
System.out.println("空闲内存量：" + Runtime.getRuntime().freeMemory());
}
}
package test.Runtime;

public class TestRuntimeHook {
public static void main(String[] args) {
Runtime.getRuntime().addShutdownHook(new Thread() {
public void run() {
// 关闭线程
System.out.println("系统正在退出……");
}
});

while (true) {
String line =  System.console().readLine();
System.out.println(line);
if (line.equals("bye")) {
System.exit(0);
}
}
}
}

package test.Runtime;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;


public class TestRuntimeExec {
public static void main(String[] args) {
try {
// 打开记事本
Runtime.getRuntime().exec("notepad");
// 打开word
Runtime.getRuntime().exec("cmd /c start Winword");
// 执行批处理
Runtime.getRuntime().exec("cmd.exe /C start d:/demo/run.bat");
} catch (Exception e) {
e.printStackTrace();
}

try {
Process p = Runtime.getRuntime().exec("d:/demo/run.bat");
InputStream in = p.getInputStream();
String line = null;
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
in.close();
p.waitFor();
} catch (InterruptedException e) {  
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}


Java常用集合类

Java正则表达式

Xml与属性文件


  Java图形编程
  Java GUI库对比
  AWT多媒体编程
  AWT多媒体编程
  Swing图形界面开发
  SWT图形界面开发
  SWT增强组件库JFace
 
  Applet组件编程
  Java网络编程
  DIO非阻塞编程
  RMI分布式网络编程
  CORBA分布式网络编程
  Java反射编程与动态代理

java反射编程：

package org.amigo.reflection;
import java.awt.Button;
import java.lang.reflect.Method;
import java.util.Hashtable;
public class ReflectionTest {
public ReflectionTest() {
// TODO Auto-generated constructor stub
}
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ReflectionTest reflectionTest = new ReflectionTest();
reflectionTest.getNameTest();
reflectionTest.getMethodTest();
}
public void getNameTest() throws Exception{
System.out.println("===========begin getNameTest============");
//通过String对象获取，String类的类名
String name = "dflajdf";
Class cls = name.getClass();
System.out.println("String类名："+ cls.getName());
//通过Button对象获取button的类名
Button btn = new Button();
Class btnclass = btn.getClass();
System.out.println("btnclass类名："+ btnclass.getName());
//通过button对象获取button父类的名字
Class btnSuperClass = btnclass.getSuperclass();
System.out.println("btnSuperClass类名："+ btnSuperClass.getSimpleName() );

Class clsTest = Class.forName("java.awt.Button");
System.out.println("clsTest name: " + clsTest.getName());
System.out.println("===========end getNameTest============");
}
public void getMethodTest() throws Exception{
System.out.println("===========begin getMethodTest==========");
//通过名字获取类对象
Class cls = Class.forName("org.amigo.reflection.ReflectionTest");
//定义类数组
Class ptypes[] = new Class[2];
ptypes[0] = Class.forName("java.lang.String");
ptypes[1] = Class.forName("java.util.Hashtable");
//通过方法名和方法参数获取类的方法
Method method =cls.getMethod("testMethod", ptypes);
Object args[] = new Object[2];
//对参数赋值
args[0] = "hello,my dear!";
Hashtable<String,String> ht =new Hashtable<String,String>();
ht.put("name", "hhhhh");
args[1] = ht;
 
String returnStr = (String) method.invoke(new ReflectionTest(), args);
System.out.println("returnStr= " + returnStr);
    System.out.println("===========end getMethodTest==========");
}
public String testMethod(String str, Hashtable ht) throws Exception {
        String returnStr = "返回值";
        System.out.println("测试testMethod()方法调用");
        System.out.println("str= " + str);
        System.out.println("名字= " + (String) ht.get("name"));
        System.out.println("结束testMethod()方法调用");
        return returnStr;
}
}

java动态代理：

  Java泛型编程
  Java注释符编程
 Java 5.0 语言新特性

 

YZZKY
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础知识点
qq_35368503的博客
07-11 990
1.重写发生在继承关系中， 一般是父类的某个方法不满足于使用了，子类重写该方法。 重写要求方法名，参数列表和返回值都相同。 注意： 子类的重写方法的返回值必须等于或小于父类类被重写方法的返回值，就是说子类的返回值类型可以是父类返回值类型 的子类或者与父类返回值类型一致。 子类重写方法的访问权限不能低于父类方法中的访问权限，即父类的访问权限是public，子类访问权限不能是protected、默认不写或者private。子类的访问权限可以高于父类。 2.重载发生在同一个类中同名的方法， 一般是以统一的方式处理
Java基础知识总结（超详细整理）
热门推荐
龙源IT 的博客
07-17 28万+
Java语言的特点，1.面向对象(OOP)就是Java语言的基础，也是Java语言的重要特性。面向对象的概念：生活中的一切事物都可以被称之为对象，生活中随处可见的事物就是一个对象，我们可以将这些事物的状态特征（属性）以及行为特征（方法）提取并出来，并以固定的形式表示。 2.简单好用，Java语言是由C和C++演变而来的，它省略了C语言中所有的难以理解、容易混淆的特性（比如指针），变得更加严谨、简洁、易使用。 3.健壮性、Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。 另外，在
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
java基础知识大全(必看经典)
03-22
Java 基础知识大全 本资源摘要信息是 Java 基础知识大全的总结，涵盖了 Java 语言的基本概念、特点、历史发展等方面的知识点。以下是本资源摘要信息的详细内容： 一、 Java 语言的特点 * 面向对象：Java 语言是...
个人整理的Java基础知识大全
最新发布
10-13
个人整理的Java基础知识大全，txt文本格式的，总共接近4000多行。Java初学者非常适用，强烈推荐。
Java基础知识大全《自学宝典》
04-03
java自学宝典:java 如何实现线程的安全:线程的同步机制 * 方式一:同步代码块 * synchronized(同步监视器){ * //需要被同步的代码块(即为操作共享数据的代码) * } * 1.共享数据:多个线程共同操作的同一个数据...
java xml操作工具类
u010129251的专栏
03-25 2039
import java.io.*; import java.util.*; import javax.xml.parsers.*; import javax.xml.transform.*; import javax.xml.transform.dom.*; import javax.xml.transform.stream.*; import org.w3c.dom.*;
spring常见面试题
u010129251的专栏
04-02 1876
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。 图 1. Spring 框架的 7 个模块 组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下： 核心容器：核心容器提供 Spring 框架
java问题集锦
u010129251的专栏
04-02 1745
1、面向对象的特征有哪些方面   1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。 2.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。
java AES加密压缩文件
u010129251的专栏
04-03 1581
package com.lvhe.core.util; import java.io.File; import java.util.ArrayList; import net.lingala.zip4j.core.ZipFile; import net.lingala.zip4j.exception.ZipException; import net.lingala.zip4j.m
中文转为unicode编码
u010129251的专栏
04-03 1556
什么是Unicode: 在创造Unicode之前针对各种语言有几百种编码系统，而且这些编码系统也相互冲突，给不同语言系统的电脑进行交流带来了麻烦。因为两种相同的字符在不同的编码系统可能有完全不同的意思，这些不同甚至会对电脑带来危害。于是Unicode出现了，Unicode给每个字符提供了一个唯一的数字，不论是什么平台，不论是什么程序，不论是什么语言。它真正实现了全球电脑系统的United，作为一
java 网络通讯工具类
u010129251的专栏
03-24 1458
1. Http通讯 使用Java程序来实现HTTP文件的队列下载      序言 许多用户可能会遇到这样的情况：在网站上发现一个很好的资源，但是这个资源是分成了很多个文件存放的，如果想把它保存到本地，只有靠用户点击另存来完成保存，如果资源分了几百甚至上千上万，那简直是个灾难。 在Internet上很多的资源分成多个文件存放时，它的文件命名是有一定的规则的；正因如此，我们就可以用
java遍历json对象
u010129251的专栏
03-27 1269
Iterator keys=jsonDataObj.keys();     String key;     while (keys.hasNext()) {     key = keys.next();     if (key.equals("table")) { } else { JSONObject jsonObject2 = (JSONObject) jsonDirObj.get
深入jvm虚拟机实战
u010129251的专栏
03-27 1223
今天有个同事问如何能通过JMX获取到某个Java进程的full GC次数： 引用 hi,问个问题，怎们在java中获取到full gc的次数呢？ 我现在用jmx的那个得到了gc次数，不过不能细化出来full gc的次数 for (final GarbageCollectorMXBean garbageCollector : ManagementFactory.getGarbageColl
java xml文件操作
u010129251的专栏
03-27 1100
java xml操作
深入jvm虚拟机内存区域与OOM
u010129251的专栏
03-27 972
Java与C++之间有一堵由内存动态分配和垃圾收集技术所围成的高墙，墙外面的人想进去，墙里面的人却 想出来。 概述： 对于从事C、 C++程序开发的开发人员来说，在内存管理领域，他们即是拥有最高权力的皇帝又是执行最基 础工作的劳动人民——拥有每一个对象的“所有权”，又担负着每一个对象生命开始到终结的维护责任。 对于Java程序员来说，不需要在为每一个new操作去写配对的delete/fr
java面试基础知识.docx
11-19
Java面试基础知识 Java面试基础知识是Java开发面试的必备知识，涵盖了Java虚拟机、基础语法、面向对象、异常处理、IO、集合、线程、网络、高级问题等多方面的内容。下面是对Java面试基础知识的详细解释： **Java...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值