>>向着CTO前进>>

public class Main { static int num=0; public static void main(String[] args) { int[] arr = {4, 1, 8, 2, 3, 7, 6, 5}; Node root = new Node(arr[0]); for(int i=1; i<arr.length; i++) { root.s

public class SqString { char[] data; int length; SqString() { data = new char[30]; length = 0; } SqString(String s) { data = new char[30]; for(int i=0; i<s.length(); i++) { data[i

问题描述：         n个人编号为1~n，围成一个圈，从第一个人开始报数，123123。。。，报到3的人被踢出，如此循环，直到最后剩下一个人，请问这个人的编号是多少？？方法一：数组解法import java.util.Scanner;public class Joseph { int[] arr; Joseph(int e) { arr = new

为了能够充分地使用数组中的存储空间，把数组的前端和后端连接起来，形成一个环形的顺序表，即把存储队列元素的表从逻辑上看成一个环，称为环形队列，也叫循环队列。ps：1、队空条件：front==rear        2、队满条件：(rear+1)%maxSize == front   //少用一个空间，即最多放maxSize-1个元素。        3、初始化时front=rear=0；

public class SqQueue { int[] data; int front, rear; SqQueue() { data = new int[30]; front = rear = -1; } boolean empty() { return front == rear; } boolean enQueue(int e) { if(rear ==

public class LinkedQueue { QueueHead qh = new QueueHead(); boolean empty() { return qh.front == null; //or qh.rear == null } void enQueue(int e) { QNode q = new QNode(e); if(empt

import java.util.Scanner;public class Cartesian { public HList list = new HList(); public void create() { System.out.print("表的行数和列数: "); Scanner sc = new Scanner(System.in); list.row = sc.n

public class SqStack { public int[] data; public int top; public SqStack() { data = new int[20]; top = -1; } public boolean empty() { return top == -1; } public boolean push(int e) {

public class LinkedStack { Node head = new Node(); boolean empty() { return head.next == null; } void push(int e) { Node n = new Node(e); n.next = head.next; head.next = n; } int[]

public class DoubleLinkedList { public Node head; public DoubleLinkedList() { head = new Node(); head.next = null; head.prior = null; } //尾插法 public void createByTail(int[] arr, int n) {

public class MaxChildStr { public static void main(String[] args) { process(new String("zzzzxxxfffr")); process(new String("zzzzxxxfffrrrrr")); process(new String("zzzzxxxxxfffrrr")); p

问题描述：        n个人站成一排，编号为1~n，现在从左向右报数“1,2,1,2.。。。”，报到1的人出列，报到2的人立即站到队伍的最后，如此循环往复，直到n个人全部出列为止。public class LinkedQueue { QueueHead qh = new QueueHead(); boolean empty() { return qh.front

我的输入测试树为：ABC#D###EF##G##，这是按照先序创建二叉树的可是我的程序中返回双亲结点：char Parent(BiTree T,ElemType e)              返回左孩子  ：char Leftchild(BiTree T,ElemType e)              返回左孩子  ：char Rightchild(BiTree T,ElemT

public class Main { public static void main(String[] args) { int[] arr = {0, 2, 1, 5, 8, 2, 4, 3, 7, 6, 5}; heapSort(arr, arr.length - 1); for(int i = 1; i < arr.length; i++) { System.out.pr

public class Main { public static void main(String[] args) { int[] arr = {0, 2, 1, 5, 8, 2, 4, 3, 7, 6, 5}; shellSort(arr, arr.length); for(int i = 0; i < arr.length; i++) { System.out.print

public class BinaryTree { public static void main(String[] args) { int[] data = new int[10]; for(int i = 0; i < data.length; i++) { data[i] = (int)(Math.random() * 100) + 1; System.out.prin

Comparable & Comparator 都是用来实现集合中元素的比较、排序的，只是 Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。Comparator位于包java.util下，而Comparable位于包

可能很多java的初学者对String的存储和赋值有迷惑，以下是一个很简单的测试用例，你只需要花几分钟时间便可理解。1.在看例子之前，确保你理解以下几个术语：栈：由JVM分配区域，用于保存线程执行的动作和数据引用。栈是一个运行的单位，Java中一个线程就会相应有一个线程栈与之对应。堆：由JVM分配的，用于存储对象等数据的区域。常量池：在编译的阶段，在堆中分配出来的一

1、jvm的垃圾回收线程是优先级别很低的后台线程，因为不能一直执行，会影响程序的执行效率，另垃圾回收只会回收堆内存中的对象。2、垃圾回收算法：   引用计数法：简单，当引用的数目为0时，才会被回收。缺点：两个对象交叉引用时，即使它们没用了，也不能被回收。  标记-清除算法：引入了根集的概念，从根开始扫描，确定哪些对象可达，哪些对象不可达，不可达的对象就会被清除。  标记-整理算法：

1、ArrayListjava.util.ArrayListadd(E e) //插入尾部add(int index, E element)remove(int index)remove(Object o)get(int index)indexOf()lastIndexOf()isEmpty()size()iterator()listItera

public class Main { public static void main(String[] args) { UFSTree[] u = new UFSTree[11]; makeSet(u); union(u, 2, 4); union(u, 5, 7); union(u, 1, 3); union(u, 8, 9); union(u, 1, 2);

public class LinkList { public Node head; public LinkList() { head = new Node(); head.next = null; } //尾插法 public void createByTail(int[] arr, int n) { Node tail = head; for(int i=0; i

public class SqList { private int[] data; private int length; public SqList() { data = new int[30]; length = 0; } public boolean empty() { return length == 0; } public int length() {

1

众所周知，java中是JVM负责内存的分配和回收，这是它的优点（使用方便，程序不用再像使用c那样操心内存），但同时也是它的缺点（不够灵活）。为了解决内存操作不灵活这个问题，可以采用软引用等方法。      在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这 就像在日常生活中，从商店购买了某样物品后，如果

JAVA会产生内存泄露吗？首先，答案是肯定的。Java虽然有垃圾回收器，但依然存在泄漏。      Java内存泄漏跟C/C++内存泄漏的概念不一样：C/C++的内存泄漏是指Malloc了一些资源，最后没有free掉，内存没有回收，这个是真正意义上的内存黑洞；而Java的泄漏指，Java对象的存在对程序已经没有意义，但是对象在程序周期内一直存在，这个可能会导致Java的内存泄漏。   

import java.util.ArrayList;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;im

（doublecheck）classSingleton{       private static volatile Singleton s =null;       public static Singleton getInstance(){              if(s==null){                     synchronized(Single

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;class Liftoff implements Runnable { protected int countDown = 10; private static int taskCount = 0; private fina

题干：先输入两个值，代表矩阵的宽和长，再依次输入矩阵中的值，只能是0或1，最后求矩阵中最大正方形的边长，该正方形里面要全是1。如： 3 4       0 0 0 0       0 1 1 0       0 1 1 0输出：2import java.util.*; public class Main {     public static void main(S

ps：不是阻塞状态，如wait()不被notify唤醒时是阻塞必须在两个及两个以上对象锁时才会发生。两个人过独木桥的例子！！public class N extends Thread{ public static Object o1=new Object(); public static Object o2=new Object(); public static vo

#笨方法O(n^2)#数较少时，遍历一个数组，其值放到HashSet，再遍历另一个数组。O(n)#数多时，用BitSet,构造方法new BitSet();new BitSet(n);n为可能的最大整数，默认下，所有初始值为false。BitSet bs = new BitSet();for(int i=0; i<arr1.length; i++) {

public class N { public static void main(String[] args) { Account ac = new Account(3, "Helen"); new Drawer(ac).start(); new Depositer(ac).start(); }}class Account{ private int tot

1. 垃圾回收的意义　　在C++中，对象所占的内存在程序结束运行之前一直被占用，在明确释放之前不能分配给其它对象；而在Java中，当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾。JVM的一个系统级线程会自动释放该内存块。垃圾回收意味着程序不再需要的对象是"无用信息"，这些信息将被丢弃。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。事实上，除了释放

public class findMaxChildArray { public static void main(String[] args) { //int[] arr = new int[]{5,-4,2,3,7,-1, -4, 3, 6,-8,6}; int[] arr = new int[]{-5,-4,2,3,7,-1, -4, 3, 6,-8,6}; //int[]

一、什么是反射机制         简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，     那么就可以通过反射机制来获得类的所有信息。 二、哪里用到反射机制         有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码，     Class.forName("com.mysql.jdbc.

public class Test { public static void main(String[] args) { System.out.println(new Test().sqrt(13)); } int sqrt(int x ){ int left = 1, right = x/2+1; int last_mid=0; while(left<=right){

public class RenMingBi { private static final char[] data = new char[]{ '零','壹','贰','叁','肆','伍','陆','柒','捌','玖' }; private static final char[] units = new char[]{ '元','拾','佰','仟','万','拾','佰'

Java内存在分配和回收的过程中会产品很多的问题，下面来说一说可能会产生的问题。1、垃圾处理              从程序运行的根节点出发，遍历整个对象引用，查找存活的对象。那么在这种方式的实现中，垃圾回收从哪儿开始的呢？即，从哪儿开始查找哪些对象是正在被当前系统使用的。上面分析的堆和栈的区别，其中栈是真正进行程序执行地方，所以要获取哪些对象正在被使用，则需要从Java栈开

Java内存管理无非就是对内存进行分配和释放。对于分配来说，基本类型和对象的引用存储到栈中，常量存储到常量池中，对象存储到堆上，这是一般的分配。而对于回收来说要复杂的多，如果回收不好，还可能造成分配出去的内存得不到回收而造成内存泄漏。    这一篇将简单介绍一下Java内存的分配，下一篇将介绍内存的回收及内存泄漏等知识。1、JVM内存模型