达叔

String... args 与String[ ] args 作用相同，都是给方法传入多个String类型的参数；不同的地方在于如何赋值。比如有这个方法public void test(String... msgs){for(String m:msgs){    System.out.println(m);    }}传实参的时候以下几种方式都是可以的1、test(

API中写道：public int compareTo(String anotherString)按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此String 对象位于参数字符串之前，则比较结果为一个负整数。如果按字典顺序此 String 对象位于参数字符串

class TreeNode{ TreeNode left; TreeNode right; int val; TreeNode(int val){ this.val=val; } static void scanNodes(TreeNode root){ if(root!=null){ System.out.println("this is node :"+root

递归是非常神奇的方法，代码看起来很简洁。对二叉树的遍历和求最大深度可以用递归的方法，主要思路就是遍历左子树，再遍历右子树。如果左子树上面的结点，有右孩子，则调用右子树的方法；遍历到左子树的叶节点的时候，返回，开始遍历右子树。如果右子树上面的结点有左孩子，则调用左子树的方法，遍历到右子树的叶子结点的时候，程序结束。static void scanNodes(TreeNode root){ i

CharacterIterator是一个接口，主要用来以字符为单位来遍历文本的。StringCharacterIterator是这个接口的一个实现类。下面是一个遍历字符串的例子，通过这种方式遍历就可以不用charAt()方法了。import java.text.CharacterIterator;import java.text.StringCharacterIterator;p

思路很简单，直接上代码package go.derek;public class Judge { //递归方法 public boolean judge1(double n){ n/=2; if(n==2){ return true; } //如果始终不等于2，则肯定有以下两种情况 if(1<n&&n<2||2<n&&n<3){ return fal

利用hashmap，首先将100个数字存入map中，value初始为0；然后遍历数组，找到一个数字，把value更新为1，这样遍历完成后，就找到了那个被遗弃的数字了。代码如下。package go.derek;import java.util.*;public class FindNum { public int find(int[] arr){ Map map=new Ha

java多线程问题，主要考察的就是如何创建线程。值得思考一下的是最后的运行结果~程序结束的时候j的值是多少呢？如果每个线程执行的次数都相同，那么结果当然是0了。因为这两对线程两两抵消。最后j就为0了。代码如下：package go.derek;public class ThreadTest { private int j; private synchronize

题目：用c/c++,不借助任何系统函数，实现字符串的反转，如输入apple，输出elppa真是哪壶不开提哪壶，C语言本来我就才疏学浅。。。写个java的糊弄一下吧。。public class Reverse { public String reverse(String str){ char[] arr=new char[str.length()]; for(int i=str

这个问题需要了解一下File这个类的几个常用方法。大家可以直接在代码中体会一下。package go.derek;import java.io.*;import java.util.regex.Matcher;import java.util.regex.Pattern;public class Findfile { public void find(String path,

原始的冒泡排序相对而言是非常耗时的，即使一个数组经过几轮交换已经变的有序了，例如[2,1,3,4,5,6,7]这个数组，经过第一轮，已经变成有序的了，但顽固的冒泡还是要继续进行没有营养的两两比较，从而牺牲了时间。如果用一个flag来判断一下，当前数组是否已经有序，如果有序就退出循环，这样可以明显的提高冒泡排序的表现~由于冒泡排序的时间复杂度为O(n*n)所以当数据越多的时候，越慢，非常不适

自己动手写排序算法，快速排序是比较不好写的了~import java.util.*;class Test{ public void quickSort(int[] arr,int low,int high){ if(low<high){ int i=low; int j=high; int x=arr[low]; while(i<j){ while(

1、冒泡排序是排序里面最简单的了，但性能也最差，数量小的时候还可以，数量一多，是非常慢的。它的时间复杂度是O（n*n），空间复杂度是O（1）代码如下，很好理解。public void bubbleSort(int[] arr){ int temp=0; for(int i=0;i<arr.length;i++){ for(int j=arr.length-1;j

题目是某缓存系统采用LRU算法，假定缓存容量为4，并且初始为空，那么在顺序访问以下数据项的时候，1,5,1,3,5,2,4,1,2出现缓存直接命中的次数是（）次，最后缓存中即将准备淘汰的数据项是（）。先解释下概念吧LRU（least recently used）算法：就是把最近一次使用时间离现在时间最远的数据删除掉。更多详细的了解请看我写的这篇博文如何用LinkedHashMa

阿里巴巴笔试考到了LRU，一激动忘了怎么回事了。。准备不充分啊。。缓存这个东西就是为了提高运行速度的，由于缓存是在寸土寸金的内存里面，不是在硬盘里面，所以容量是很有限的。LRU这个算法就是把最近一次使用时间离现在时间最远的数据删除掉。先说说List：每次访问一个元素后把这个元素放在 List一端，这样一来最远使用的元素自然就被放到List的另一端。缓存满了t的时候就把那最远使用的元素remov

下午就要去参加阿里巴巴的笔试了，早上起来做一道据说是阿里巴巴13年校招的考题找找手感。。。题目是寻找一个字符串中最长的重复子串。 如 abcdabc 最长重复串 是abc这个题还是挺有意思的（不过好像没啥难度，我竟然没有调试，写一次就运行出来了。。）用简单的两层循环，结合substring()方法就可以了直接上代码吧~class Test{ String reg,left;

最近在学C语言，每写一个C语言程序，就再写一个java的实现，发现简单的小程序，还是C语言简单啊。。。java写起来要复杂繁琐的多。。说到统计，通常的需求是统计一篇文章的各种信息数据。但神需求无处不在，只要技术使用正确就一定可以解决的。直接上代码。import java.util.*;class Test1{ public static void main(String[] a

今天在Linux下用c语言写个小程序玩玩，主要就是根据华氏温度计算摄氏温度。公式是：摄氏度=（5/9)*(华氏度-32)代码很简单~#includemain(){ int c,f; /*c代表摄氏度，f代表华氏度*/ int lower,upper,step; lower=0; upper=300; step=20; f=lower; while(f<=upper) {

有一个字符串的时间，比如"2012-12-31 16:18:36" 与另一个时间做比较，如果前者比后者早，则返回true，否则返回false。为此，我设计了一个方法。import java.util.*;import java.text.ParseException;import java.text.SimpleDateFormat;class Test{ public bool

所谓Stack Overflow就是栈里面放的东西太多了，溢出了。大家知道栈里面存放的是基本数据类型还有引用类型。下面看这个程序class Test { public static void main(String[] args) { String[] str={"a","b"}; Test.main(str);

ant构建过程中编码错误的解决方案 encoding="UTF-8"/> <jar destfile="dist/yuetao_rpt.jar" basedir="build/classes"/> <java classname="mian.MainRpt.java" classpath="build/classes">

原理跟用java生成jsp的servlet差不多。我们可以用printStream来向html文件里输出数据。先创建一个StringBuilder对象，通过append方法来为其添加html语句。如下面例子所示:StringBuilder sb = new StringBuilder(); Properties fileProperties = getProperties("file"

面向对象versionimport java.util.*;class Check { int a,b,c; public void init() { Random rd=new Random(); a=rd.nextInt(21); b=rd.nextInt(21); if(Math.random()<0.25) { System.out.print(a+"+"+

昨天看了一下午《Thinking in java》，今早终于有了种厚积薄发的感觉~import java.io.*; import java.util.*; class Copy { static void copy(String from,String to) throws IOException { BufferedReader in=

输入一个字符串，然后讲该字符串循环右移4位例如输入abcdefgh    则输出efghabcd下面有两个方法，第一个是将字符串转换为一个字符数组char[ ];然后循环复制替换import java.util.*;class Move { public static void main(String[] args) { Scanner sc=new Scanne

一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和，求所有子数组的和的最大值下面是一个效率很低的方法两层循环，思路是分别以每一个元素为起点，定义一个temp值保存现有的最大和，如果遍历到的连续子数组的和大于temp那么则交换两者的值。import java.util.*;class BigChild{ public sta

这个思路很简单，逻辑清晰，大家一看就明白了。当然有还有很多方法，欢迎大家补充。import java.util.*;class Compare { public static void main(String[] args) { Scanner sc=new Scanner(System.in); int x=sc.nextInt(); int y=sc.nextIn

思路很简单，大家一看就懂~import java.util.*;class WhichDay { static void whichday(String date) { int days=0; String[] str1=date.split("年"); int year=new Integer(str1[0]); String[] str2=str1[1].split

猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。思考片刻~递归算法破之。切记，递归要向已知方向递归。import java.util.*;class Peach{ static int num;

思路很简单，大家一看就懂。import java.util.*;class Max{ static int a,b,c,d,e,f,g,h,i,j; public static void main(String[] args) { int[] num=new int[100]; Random rd=new Random(); for(int n=0;n<100;n++

规则如下：三个骰子点数相同>两个骰子点数相同>三个骰子点数不同相同情况比点数之和。代码如下import java.util.*;class Game { static int l,m,n; int w; public int num() { Random rd=new Random(); int a=rd.nextInt(6)+1; int b=rd.nex

效果图如上代码如下import java.util.*;class Yanghui { public static void main(String[] args) { Scanner sc=new Scanner(System.in); System.out.print("请输入最大值："); int max=sc.nextInt(); for(int i=

在网上看到这个题目，自己动手试了一下，思路很简单，大家一看就懂。import java.util.*;class Split { void go(String str,int n) { String result=null; int num=0; if(str.length()%n==0) num=str.length()/n; num=(int)str.leng

先看下java源码中对hashcode()方法里面用到的变量的声明。 /** The value is used for character storage. */ private final char value[];//定义一个字符数组value，用于存储字符串里面的字符 /** The offset is the first index of the storage

List接口里面有个重要方法就是contains（），使用这个方法就可以去重了。核心代码如下BufferedWriter bo=new BufferedWriter(new FileWriter("特殊符号.text")); String line=null; List list=new ArrayList(); while((line=br.readLine())!=n

在java的IO体系中，写文件通常会用到下面语句BufferedWriter bo=new BufferedWriter(new FileWriter("sql语句.txt"));用到这个的时候一定不能忘了他的伴侣代码。。bo.close();或者bo.flush();实际上，FileWriter在写文件时，会把内容存储到一块缓冲区中，当缓冲区满后，才会把缓冲区中的内容存入数据库，内容

解决问题的核心在这个正则表达式"\\s*|\t|\r|\n"核心代码如下：String dest = ""; Pattern p = Pattern.compile("\\s*|\t|\r|\n"); Matcher m = p.matcher(str); dest = m.replaceAll("");大家可以把这个包装成一个方法，直接拿去用。

最近用了好多正则表达式，都是循规蹈矩的在前面加上^在后面加上$像这个样子"^[.]\\S+$"，但实际上我在eclipse和editplus下都试了一下，不加前缀和后缀也是可以的。代码如下import java.util.*;import java.util.regex.Pattern;import java.util.regex.Matcher;class Test1 {

说到遍历，首先应该想到for循环，然而map集合的遍历通常情况下是要这样在的，先要获得一个迭代器。Map map = new HashMap<>(); Iterator it = map.entrySet().iterator(); while (it.hasNext()) { Map.Entry entry = (Map.E

这里要用到一个Comparator的接口，里面只有一个方法，compare（）,我们实现这个接口就好，很简单private class ValueComparator implements Comparator> { public int compare(Map.Entry mp1, Map.Entry mp2) {