JAVA编程简历

下面就是小编给大家整理的JAVA编程简历，本文共12篇，希望您能喜欢！本文原稿由网友“winzhe”提供。

篇1：JAVA编程简历

姓名：李XX性别：男出生日期：1983-07-06

居住地：上海市工作年限：两年移动电话：********

目前年薪：4-5万

[教育经历]

/09-/07河北理工大学计算机科学与技术专业本科

[自我评价]

1.熟练使用SSH框架和常用设计模式熟练应用数据库知识

2.熟悉JDBC,MySQL,Oracle；可以进行用例分析及数据建模，

3.有良好的.开发习惯和设计思路，有较好的学习能力及团队精神，积累了1年多的B/S架构开发经验。

4.有良好的英语文档阅读能力。目标在3年内成为合格的高级软件工程师,希望您能给我这样一个机会展示自己.

求职意向

[希望行业]：计算机软件

目标职能：Java软件工程师及相关职位

[工作经验]

2006/07-/06上海新致软件PG

职责：从事Java、jsp、struts等代码编写；项目测试及日语化。能够阅读，理解日文试样书。日语水平与日语考试3级相当。

2008/06-至今慧桥信息科技有限公司Java软件工程师

职责：参与项目的开发和实施全过程，完成相应阶段文档编制，如分析、设计、编码、测试等。

篇2：java编程就业前景

软件开发行业中最流行的开发语言就是Java语言，但是Java语言流行了十几年，从事Java开发行业的人也是最多的，现在学习Java开发还有前途吗?

Java开发行业前景

Java语言是一门很实用的语言，在互联网的应用十分广泛，目前采用JAVA语言开发的网站也越来越多，所以对Java开发人才的需求量也是倍增。虽然说现在新的开发语言在市场上越来越多，但是根据有关数据表明，在所有程序员中，Java开发程序员就占据20%的比例。这说明Java开发仍然是一个热潮，它强大的影响力已经证明了自己的王者风范。

一位软件开发行业的前辈讲到，不可否认Java开发语言本身的庞大，它是全球最流行的开发语言，给程序界带来很大的影响，势必继续影响着整个互联网。

从人才需求方面看，软件开发是当下的发展趋势，而我国的软件开发人才极为缺乏，其中java人才缺口最大，对java软件工程师的需求达到全部需求量的60%-70%，如今互联网的趋势是移动端，Java又是安卓开发的基础，所以人才的需求又增加一大波。

从薪资水平看，java软件工程师的薪资相比其他开发工程师高出许多，具备3-5年工作经验的开发人员年薪都可以达到20到30万元。

所以说java的发展前景还是非常可观的，如果可以真正学好java这门技能，那我们的发展前景也是不可估量。现在很多人选择参加培训机构，这不失为一个最佳的选择，当然最重要的还是靠自己的努力。

Java软件工程师的就业前景

java软件工程师就业前景如何是许多软件工程师都困惑的问题，他们有的时候甚至不知道自己选择的行业是否正确，为了帮助许多java软件工程师走出困境，下面就是专门针对java软件工程师就业前景进行详细的解析，在了解了相关的情况下，不知道你否还会坚持在软件工程师的行业中继续发展。

java软件工程师就业前景的好坏主要从Java的应用领域来看，Java语言的应用方向主要表现在以下三个方面：

首先是大中型的商业应用，包括我们常说的企业级应用(主要指复杂的大企业的软件系统)、各种类型的网站，Java的安全机制以及它的跨平台的优势，使它在分布式系统领域开发中有广泛应用;

其次是桌面应用，就是常说的C/S应用，主要用来开发运行于不同的操作系统上的桌面应用程序;

再次是移动领域应用，主要表现在消费和嵌入式领域，是指在各种小型设备上的应用，包括手机、PDA、机顶盒、汽车通信设备等。

近年来我国信息化发展越来越快，使得全国各地的信息化建设如火如荼，出现了大量的信息化人才尤其是Java软件人才的缺口，而我国信息化人才培养还处于发展阶段，导致社会实际需求人才基数远远大于信息化人才的培养基数，使得数以万计的中小企业急需全面系统掌握Java软件开发基础技能与知识的软件工程师。

根据11月TIOBE开发语言排行榜宣布的流行开发语言的排名结果，Java仍然高居榜首，在国内的软件开发企业中，Java语言的使用比例也排名第一。

我国目前对软件人才的需求已达20万，并且以每年20%左右的速度增长。在未来5年内，合格软件人才的需求将远大于供给。

根据IDC的统计数字，在所有软件开发类人才的需求中，对Java工程师的需求达到全部需求量的60%~70%。应该说Java软件工程师的就业机会和前景是非常大的。再加上Java软件工程师不仅IT专业企业需要，广大的非IT企业也需要。前景是非常乐观的。

同时，Java工程师的薪水相对较高。通常来说，具有3~5年开发经验的工程师，拥有年薪10万元是很正常的一个薪酬水平。但是，对Java人才需求旺盛的IT企业却很难招聘到合格的Java人员。

其中，最根本的原因就是许多计算机专业的毕业生在读期间没有掌握实用的技能与经验，距离企业的实际用人需求有较大的差距。因此，计算机专业的大学生欲成为Java工程师，最便捷的一条路就是参加以实战项目为主要教学方法的Java职业技能培训，从而有效地缩短同企业具体用人需求之间的差距。

要使用Java语言胜任企业工作并不容易。比如要成为一名Java架构师，必须精通设计、需求分析、各种开源工具、JavaEE的底层技术;熟悉工作流程、权限框架、门户框架等。而要成为一名Java普通程序员，必须具备基本的J2EE技术(JSP、Servlet、Java语言)，SSH(Struts、Spring、Hibernate)框架开发，一定的数据库设计能力和数据库使用经验，熟悉Web开发技术(比如html+css+Javascript，会ajax更好)。

当前世界各地持有JavaProgrammer证书的人员供需差距极大，迫使企业不得不用高薪聘请Java程序员。因此，JavaProgrammer的含金量比一般的技术人员要高出很大一块。在美国、加拿大、澳大利亚、新加坡等发达国家和中等发达国家，持有JavaProgrammer认证证书的人年薪均在4-10万美金，而在国JavaProgrammer认证的程序员也有极好的工作机会和很高的薪水。

java软件工程师就业前景其实不是一成不变的，而是随着人们的他的需要而变化的，当我们大量需要的时候往往java软件工程师就业前景就会比较明朗，相反的我们不需要了，那么java软件工程师就业前景还会好吗?我们要做的不是看前景的好坏，而是针对自己展开分析。

更多热门文章推荐：

1.Java就业前景如何

2.就业前景最好的十大专业

3.数控技术未来就业前景怎么样?

4.2016学习IT的就业前景分析

5.20信息管理与信息系统就业前景如何

6.2016年数控技术就业前景怎样?

7.软件工程师的就业前景

8.专业就业率前十的排名

9.数控技术专业毕业生就业前景怎么样?

10.JAVA工程师的就业前景分析

篇3：java 网络编程 面试

1. 读写原始数据，一般采用什么流?( )

A InputStream

B DataInputStream

C OutputStream

D BufferedInputStream

2. 为了提高读写性能，可以采用什么流?( )

A InputStream

B DataInputStream

C BufferedReader

D BufferedInputStream

E OutputStream

F BufferedOutputStream

3. 对各种基本数据类型和String类型的读写，采用什么流?( )

A DataInputStream

B BufferedReader

C PrintWriter

D DataOutputStream

E ObjectInputStream

F ObjectOutputStream

4. 能指定字符编码的I/O流类型是：( )

A Reader

B InputStreamReader

C BufferedReader

D Writer

E PrintWriter

F ObjectInputStream

G ObjectOutputStream

H OutputStreamWriter

5. File类型中定义了什么方法来判断一个文件是否存在?( )

A createNewFile

B renameTo

C

D exists

6. File类型中定义了什么方法来创建一级目录?( )

A createNewFile

B exists

C mkdirs

D mkdir

7. 对文本文件操作用什么I/O流?( )

A FileReader

B FileInputStream

C RandomAccessFile

D FileWriter

8. 在unix服务器www.openlab.com.cn上提供了基于TCP的时间服务应用，该应用使用port为13。创建连接到此服务器的语句是：( )

A Socket s = new Socket(“www.openlab.com.cn”, 13);

B Socket s = new Socket(“www.openlab.com.cn:13”);

C Socket s = accept(“www.openlab.com.cn”, 13);

9. 创建一个TCP客户程序的顺序是：( )

A 获得I/O流

B 关闭I/O流

C 对I/O流进行读写操作

D 建立socket

E 关闭socket

10. 创建一个TCP服务程序的顺序是：( )

A 创建一个服务线程处理新的连接

B 创建一个服务器socket

C 从服务器socket接受客户连接请求

D 在服务线程中，从socket中获得I/O流

E 对I/O流进行读写操作，完成与客户的交互

F 关闭socket

G 关闭I/O流

11. Java UDP编程主要用到的两个类型是：( )

A UDPSocket

B DatagramSocket

C UDPPacket

D DatagramPacket

12. TCP/IP是一种：( )

A 标准

B 协议

C 语言

D 算法

[java 网络编程 面试]

篇4：java编程学习方法有哪些

Java是一种简单的，跨平台的，面向对象的，分布式的，解释的，健壮的安全的，结构的中立的，可移植的，性能很优异的多线程的，动态的语言。java编程学习方法有哪些呢?

一.初接触软件技术,先挑技术门槛低的技能方向入手。

如果你完全是个外行，只懂得电脑的一般操作和OFFICE的使用，就先从网页制作开始学习，学习DREAMWEAVER的使用。比如自己设定一个小目标：做个人主页，在纸上画框架，然后用DREAMWEAVER慢慢实现，不会使用，就上网搜教程，最好搜到视频、动画或者带图的教程，通俗易懂。用DREAMWEAVER做网页的同时要对照看代码，再找HTML、CSS、JAVASCRIPT的系统手册。这些手册不要一篇一篇的看，你刚开始只看一个大概，了解能实现什么样的效果，在具体项目中再通过手册查代码命令。

熟悉完前台制作后，要了解脚本语言，比如JSP、PHP、C#之类。自己再设定一个小目标;如留言簿。上网搜源码，下载到本地，一步一步的配置环境变量、启动TOMCAT服务器、部署JSP代码，设置好ACCESS数据库(数据库先从简单的ACCESS开始)。这样做的好处是从整体上了解搭建一个WEB运行环境需要的步骤和环节，利于后期的学习。

数据库软件可以从简单的MYSQL、MSSQL开始，了解一下如何建表结构，查看数据，权限机制就可以，更多的内容等接触实际项目的时候再学习也来得及。学习方式同样的是买一本大而全的教材，先大体翻一遍，或者请技术前辈勾划几个常用的重点内容，其他的使用整体了解一下。

以上学习教程针对WEB开发技术的，如果是做偏底层开发，就不适合了。

二.从实用角度出发来学习.

在学习每一个环节技术时，都要给自己设定一个小功能目标，以目标来驱动自己学习。如果盲目看书、各个技术环节都要去了解，就会对学习产生抵触，结果是什么都学不进去。

大部培训机构和大学里的教学方式就是这样，比如讲JAVA，对初学者讲大通的面向对象思想：继承、接口、抽象类，把JDK所有的包都详细讲一遍，IO流、socket编程、SWING等等，并不说这些不重要，只是对于初学者理解不了这些概念。我比较偏向于先从形象的，容易理解的学起，比如能基于关系型数据库做个单表的增删改查~~

三.找个技术前辈做指导

所谓技术前辈是做过几个实际项目的的开发人员，他们很清楚在实际项目中最常用的技术是哪些，哪些开源项目好用。

找到技术前辈并不是帮你解决几行代码调试不通的问题，关键是帮你介绍一两本入门的书、介绍一些网上好的资源网站、指导学习哪些常用类、遇到麻烦的技术难点用什么开源组件等等。

有个好师傅非常非常的重要!! 让你少走很多弯路。

四.脸皮要厚,不怕被人笑话

刚开始做技术，进入软件公司工作，就很不自信，总觉得自己这也不知道，那也不了解。其实，没关系，你要对自己树立信心，你要明白一点：所有的技术都没什么难度，都是熟能生巧的过程。 所以，一遇到问题就赶紧问老开发人员，平时上下班，吃饭时多跟他们聊;业务上不懂的就问项目经理和需求分析员，没什么关系的。

我再讲个极端一点的情况，我个人刚学技术时，头两家公司都是把我开掉的，为什么呢?因为我那时水平确实太差了。 但每一次公司工作的机会都让我进了一步。后来遇到几个同行，有好几个人也有同样被开除的经历。为了学习技术，就别担心面子的问题了。

在外打工，遇到的同事在你人生过程之中都是过客，没有人会把你某段代码不会写当成笑话记一辈子的。坦城、自信很重要!

五.在打工过程中多长心眼,除技术外,想积累人脉.技能.项目经验

我们不能做一辈子程序员，以后总要升级转行，做项目经理、做售前、或者是公司高管。但这些都需要前期的积累。你在打工过程中，除了挣钱，还要积累技术、积累人脉关系，包括与技术和销售同事之间(以后做项目，遇到技术难点得找人问;或者同事以后接到项目要找人合作说不准就想到你了)、与客户之间的(这个很重要)，积累项目经验，主要是学习各个行业的业务知识，象电信、金融、电力、ERP等。如果你进了某个行业，比如电信、电力，你再跳槽就最好别换行业了。

篇5：java面试编程题

1.现在输入n个数字，以逗号，分开;然后可选择升或者降序排序;按提交键就在另一页面显示按什么排序，结果为，提供reset

import java.util.*;

public class bycomma{

public static String[] splitStringByComma(String source){

if(source==null||source.trim.equals(“”))

return null;

StringTokenizer commaToker = new StringTokenizer(source,“,”);

String[] result = new String[commaToker.countTokens()];

int i=0;

while(commaToker.hasMoreTokens()){

result[i] = commaToker.nextToken();

i++;

}

return result;

}

public static void main(String args[]){

String[] s = splitStringByComma(“5,8,7,4,3,9,1”);

int[] ii = new int[s.length];

for(int i = 0; i

ii[i] =Integer.parseInt(s[i]);

}

Arrays.sort(ii);

//asc

for(int i=0;i

System.out.println(ii[i]);

}

//desc

for(int i=(s.length-1);i>=0;i--){

System.out.println(ii[i]);

}

}

}

2.编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半 个”。

代码：

public static boolean isLetter(char c){

int k=0X80;

return c/k==0?true:false;

}

public static int lengths(String strSrc){

if (strSrc==null){

return 0;

}

int len=0;

char[] strChar=strSrc.toCharArray();

for (int i=0;i

len++;

if (!isLetter(strChar[i])) len++;

}

return len;

}

public static String subString(String origin,int len){

if (origin==null || origin.equals(“”)|| len<1){

return “”;

}

if (len>lengths(origin)){

return origin;

}

byte[] strByte=new byte[len];

System.arraycopy(origin.getBytes(),0,strByte,0,len);

int count=0;

for (int i=0;i

int value=(int)strByte[i];

if (value<0) count++;

}

if (count % 2 !=0){

//len=(len==1)?++len:--len;

--len;

}

return new String(strByte,0,len);

}

public static void main(String[] args) {

System.out.println(“”+ subString(“我ABC汉DEF”,6));

}

3、排序都有哪几种方法?请列举。用JAVA实现一个快速排序。

排序的方法有：插入排序(直接插入排序、希尔排序)，交换排序(冒泡排序、快速排序)，选择排序(直接选择排序、堆排序)，归并排序，分配排序(箱排序、基数排序)

快速排序的伪代码。

/ /使用快速排序方法对a[ 0 :n- 1 ]排序从a[ 0 :n- 1 ]中选择一个元素作为m I d d l e，该元素为支点把余下的元素分割为两段left 和r I g h t，使得l e f t中的元素都小于等于支点，而right 中的元素都大于等于支点递归地使用快速排序方法对left 进行排序递归地使用快速排序方法对right 进行排序所得结果为l e f t + m I d d l e + r I g h t

//以下为java程序实现的快速排序算法：

public static void sort(int[] data) {

quickSort(data,0,data.length-1);

}

public static void quickSort(int[] data,int low,int high){

int pivotIndex=(low+high)/2;

swap(data,pivotIndex,high);

int k=partition(data,low-1,high,data[high]);

swap(data,k,high);

if ((k-low)>1) partition(data,low,k-1);

if ((high-k)>1) partition(data,k+1,high);

}

public static int partition(int[] data int low,int high, int pivot ){

do {

while (data[++low]

while (high!=0 && data[--high]>pivot);

swap(data,low,high);

}

while (low

swap(data,low,high);

return low;

}

public static void swap(int[] data int low,int high){

int tmp=data[low];

data[low]=data[high];

data[high]=tmp;

}

public static void main(String[] args){

int[] data = new int[]{89,32,425,32,78,1,53,92};

sort(data);

}

4.试用递归的方法写一下计算菲波那契数列的通项f(n),已知f1=1,f2=1,以后每项都是前两项的和。

..............

public static long fibonacci(long m){

if (m==0 || m==1) return m;

else return fibonacci(m-1)+fibonacci(m-2);

}

5. 写一个Singleton出来。

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

一般Singleton模式通常有几种种形式:

第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的 getInstance方法获取对它的引用,继而调用其中的方法。

Public class Singleton {

private Singleton(){}

//在自己内部定义自己一个实例，是不是很奇怪?

//注意这是private 只供内部调用

private static Singleton instance = new Singleton();

//这里提供了一个供外部访问本class的静态方法，可以直接访问

public static Singleton getInstance() {

return instance;

}

}

第二种形式:

public class Singleton {

private static Singleton instance = null;

public static synchronized Singleton getInstance() {

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率!

if (instance==null)

instance=new Singleton();

return instance;

}

}

其他形式:

定义一个类，它的构造函数为private的，所有方法为static的。

一般认为第一种形式要更加安全些

6、创建一个静态方法，给它传入一个对象，请循环的打印出该对象所在类的类名和所实现的方法名(华为笔试最后一道编程)

import java.lang.reflect.*;

public class Test{

public static void test(Object obj){

Class clazz=obj.getClass();

//System.out.println(“类名:”+clazz.getName());

Method[] ms=clazz.getDeclaredMethods();

long len=Array.getLength(ms);

for(int i=0;i

System.out.println(“类名:”+clazz.getName()+“方法名:”+ms[i].getName());

}

}

class A{

public void b(){}

public void c(){}

public void d(){}

public void e(){}

}

public static void main(String[] args){

Test t=new Test();

Test.A a=t.new A();

test(a);

}

}

7、假设字符串类似这样的aba和aab就相等，现在随便给你二组字符串，请编程比较他们看是否相等

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String s = null;

try {

s = br.readLine();

} catch (IOException e) {

e.printStackTrace();

}

StringTokenizer st = new StringTokenizer(s);

String s1 = st.nextToken();

String s2 = st.nextToken();

byte[] sa1 = s1.getBytes();

byte[] sb2 = s2.getBytes();

Arrays.sort(sa1);

Arrays.sort(sb2);

String ss1 = new String(sa1);

String ss2 = new String(sb2);

if(ss1.equals(ss2))

System.out.println(“equal”);

else

System.out.println(“not equal”);

8、给你一组字符串如：iu7i8hy4jnb2，让你编程输出里面的数字：7842

用正规表达式：“iu7i8hy4jnb2”.replaceAll(“[^\\d]”,“”);

9、给你一组字符串让你把它倒叙输出

public static String flashBack(String origin) {

String result = “”;

for (int i = origin.length(); i >0; i--) {

String tmp = origin.substring(i - 1, i);

result += tmp;

}

return result;

}

10、给你一组字符如{1，3，4，7，2，1，1，5，2}，让你输出里面出现次数最多且数值最大的一个，出现几次

public void fun4() {

int[] a = { 4, 1, 2, 4, 5, 1, 1, 1, 5, 1, 3, 4, 5 };

Arrays.sort(a);

for (int i = 0; i < a.length; i++) {

System.out.print(a[i] + “ ”);

}

System.out.println();

int maxNumber = a[a.length - 1], maxCount = 1;

int curNumber = a[a.length - 1], curCount = 1;

for (int i = a.length - 1; i >0; i--) {

curNumber = a[i];

if (a[i] == a[i - 1]) {

curCount++;

} else {

System.out.println(“i=” + i + “,curCount=” + curCount+ “,maxCount=” + maxCount + “,maxNumber=” + maxNumber);

if (curCount >maxCount) {

maxCount = curCount;

maxNumber = curNumber;

}

curCount = 1;

}

}

if (curCount >maxCount) {

maxCount = curCount;

//maxNumber = curNumber;

}

System.out.println(“curCount=” + curCount + “,maxCount=” + maxCount + “,maxNumber=” + maxNumber);

}

11、求两个数的公约数，M，N

int divisor =1;

for (int i = 2; i <= b; i++) {

if(a%i==0 && b%i==0){

divisor = i;

}

}

System.out.println(a+“和”+b+“的最大公约数是:”+divisor);

}

12、实现数组复制

public void fun8(){

int[] a = {1,2,3,4,56,7,8};

int[] b = (int[])a.clone();

Conica.print(a);

Conica.print(b);

b[0]=100;

Conica.print(a);

Conica.print(b);

}

13、冒泡排序的实现

public void fun9(){

int[] a = {1,5,2,6,8,74,1,25,69,8};

Conica.print(a);

for(int i=0; i

for(int j=0; j

if(a[j]>a[j+1]){

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

Conica.print(a);

}

14、编程显示某一文件目录下的文件名

public void fun10(){

File file = new File(“G:\\03月份”);

if(file.exists()){

if(file.isDirectory()){

String[] files = file.list();

Conica.println(files);

}

}

}

15、从键盘输入4个十进制数字字符，将其转换为4位时间之数并显示出来

16、编程实现统计文本文件中某个单词的出现频率，并输出统计结果

用HashMap来解决

假设单词不存在跨行的,每个单词用,. ;分割

public static void countNum() throws IOException {

BufferedReader br = null;

try {

br = new BufferedReader(new FileReader(“c://file.txt”));

Map map = new HashMap();

for (String s = br.readLine(); s != null; s = br.readLine()) {

StringTokenizer st = new StringTokenizer(s, “,. ;”);

while (st.hasMoreTokens()) {

String temp = st.nextToken();

if (map.containsKey(temp)) {

map.put(temp, new Integer((Integer)map.get(temp) + 1));

} else {

map.put(temp, new Integer(1));

}

}

}

for (Iterator it = map.entrySet().iterator(); it.hasNext();) {

Map.Entry entry = (Map.Entry) it.next();

System.out.println(entry.getKey() + “-->” + entry.getValue()

+ “times”);

}

} finally {

br.close();

}

}

17、编程模仿DOS下的dir命令，列出某个目录下的内容

18、编程说明String和StringBuffer字符串的区别

19、编程计算N!的程序，一个使用递归方法，一个不用递归方法

递归 :

long fuction(int n){

if (n==0) return 1;

else

return n* fuction(n-1);

}

不递 :

long s=1;

for(int i=2;i<=n;i++)

{

s*=i;

}

20、编程实现ASCII码和Unicode码之间的转换

21.用1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，如：512234、412345等，要求： “4 ”不能在第三位， “3 ”与 “5 ”不能相连.

此题具体算法及程序可参考：

topic.csdn.net/u/0114/14/1170e023-e8f0-4331-8bd8-516c6f1e40da.html

22。一个字符串中可能包含a~z中的多个字符，如有重复，如String data=“aavzcadfdsfsdhshgWasdfasdf”，求出现次数最多的那个字母及次数，如有多个重复的则都求出。〔金山公司面试题〕

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.TreeSet;

public class FindRepeatChar {

public static void doString(String strInput) {

char[] chars = strInput.toCharArray();

ArrayList lists = new ArrayList();

TreeSet set = new TreeSet();

for (int i = 0; i < chars.length; i++) {

lists.add(String.valueOf(chars[i]));

set.add(String.valueOf(chars[i]));

}

System.out.println(set);

Collections.sort(lists);

System.out.println(lists);

StringBuffer sb = new StringBuffer();

for (int i = 0; i < lists.size(); i++) {

sb.append(lists.get(i));

}

strInput = sb.toString();

System.out.println(strInput);

int max = 0;

String maxString = “”;

ArrayList maxList = new ArrayList();

for (Iterator its = set.iterator(); its.hasNext();) {

String s = (String) its.next();

int begin = strInput.indexOf(os);

int end = strInput.lastIndexOf(os);

int value = end - begin + 1;

if (value >max && value >1) {

max = value;

maxString = os;

maxList.add(os);

} else if (value == max) {

maxList.add(os);

}

}

int index = 0;

for (int i = 0; i < maxList.size(); i++) {

if (maxList.get(i).equals(maxString)) {

index = i;

break;

}

}

System.out.println(“出现最多的字符为：”);

for (int i = 0; i < maxList.size(); i++) {

System.out.println(maxList.get(i) + “”);

}

System.out.println();

System.out.println(“出现最多的次数为：” + max);

}

public static void main(String[] args) {

String strInput = new String(“aavzcadfdsfsdhshgWasdfasdf”);

doString(strInput);

}

}

23.金额转换，阿拉伯数字的金额转换成中国传统的形式如：(￥1011)->(一千零一拾一元整)输出。

package test.money;

import java.text.NumberFormat;

import java.util.HashMap;

public class SimpleMoneyFormat {

public static final String EMPTY = “”;

public static final String ZERO = “零”;

public static final String NE = “壹”;

public static final String TWO = “贰”;

public static final String THREE = “叁”;

public static final String FOUR = “肆”;

public static final String FIVE = “伍”;

public static final String SIX = “陆”;

public static final String SEVEN = “柒”;

public static final String EIGHT = “捌”;

public static final String NINE = “玖”;

public static final String TEN = “拾”;

public static final String HUNDRED = “佰”;

public static final String THOUSAND = “仟”;

public static final String TEN_THOUSAND = “万”;

public static final String HUNDRED_MILLION = “亿”;

public static final String YUAN = “元”;

public static final String JIAO = “角”;

public static final String FEN = “分”;

public static final String DOT = “.”;

private static SimpleMoneyFormat formatter = null;

private HashMap chineseNumberMap = new HashMap();

private HashMap chineseMoneyPattern = new HashMap();

private NumberFormat numberFormat = NumberFormat.getInstance();

private SimpleMoneyFormat() {

numberFormat.setMaximumFractionDigits(4);

numberFormat.setMinimumFractionDigits(2);

numberFormat.setGroupingUsed(false);

chineseNumberMap.put(“0”, ZERO);

chineseNumberMap.put(“1”, ONE);

chineseNumberMap.put(“2”, TWO);

chineseNumberMap.put(“3”, THREE);

chineseNumberMap.put(“4”, FOUR);

chineseNumberMap.put(“5”, FIVE);

chineseNumberMap.put(“6”, SIX);

chineseNumberMap.put(“7”, SEVEN);

chineseNumberMap.put(“8”, EIGHT);

chineseNumberMap.put(“9”, NINE);

chineseNumberMap.put(DOT, DOT);

chineseMoneyPattern.put(“1”, TEN);

chineseMoneyPattern.put(“2”, HUNDRED);

chineseMoneyPattern.put(“3”, THOUSAND);

chineseMoneyPattern.put(“4”, TEN_THOUSAND);

chineseMoneyPattern.put(“5”, TEN);

chineseMoneyPattern.put(“6”, HUNDRED);

chineseMoneyPattern.put(“7”, THOUSAND);

chineseMoneyPattern.put(“8”, HUNDRED_MILLION);

}

public synchronized static SimpleMoneyFormat getInstance() {

if (formatter == null)

formatter = new SimpleMoneyFormat();

return formatter;

}

public String format(String moneyStr) {

checkPrecision(moneyStr);

String result;

result = convertToChineseNumber(moneyStr);

result = addUnitsToChineseMoneyString(result);

return result;

}

public String format(double moneyDouble) {

return format(numberFormat.format(moneyDouble));

}

public String format(int moneyInt) {

return format(numberFormat.format(moneyInt));

}

public String format(long moneyLong) {

return format(numberFormat.format(moneyLong));

}

public String format(Number moneyNum) {

return format(numberFormat.format(moneyNum));

}

private String convertToChineseNumber(String moneyStr) {

String result;

StringBuffer cMoneyStringBuffer = new StringBuffer();

for (int i = 0; i < moneyStr.length(); i++) {//123363

cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(

i, i + 1)));

}

// 拾佰仟万亿等都是汉字里面才有的单位，加上它们

int indexOfDot = cMoneyStringBuffer.indexOf(DOT);

int moneyPatternCursor = 1;

for (int i = indexOfDot - 1; i >0; i--) {

cMoneyStringBuffer.(i, chineseMoneyPattern.get(EMPTY

+ moneyPatternCursor));

moneyPatternCursor = moneyPatternCursor == 8 ? 1

: moneyPatternCursor + 1;

}

String fractionPart = cMoneyStringBuffer.substring(cMoneyStringBuffer

.indexOf(“.”));

cMoneyStringBuffer.(cMoneyStringBuffer.indexOf(“.”),

cMoneyStringBuffer.length());

while (cMoneyStringBuffer.indexOf(“零拾”) != -1) {//inclusive. exclusive.

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零拾”),

cMoneyStringBuffer.indexOf(“零拾”) + 2, ZERO);

}

while (cMoneyStringBuffer.indexOf(“零佰”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零佰”),

cMoneyStringBuffer.indexOf(“零佰”) + 2, ZERO);

}

while (cMoneyStringBuffer.indexOf(“零仟”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零仟”),

cMoneyStringBuffer.indexOf(“零仟”) + 2, ZERO);

}

while (cMoneyStringBuffer.indexOf(“零万”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零万”),

cMoneyStringBuffer.indexOf(“零万”) + 2, TEN_THOUSAND);

}

while (cMoneyStringBuffer.indexOf(“零亿”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零亿”),

cMoneyStringBuffer.indexOf(“零亿”) + 2, HUNDRED_MILLION);

}

while (cMoneyStringBuffer.indexOf(“零零”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零零”),

cMoneyStringBuffer.indexOf(“零零”) + 2, ZERO);

}

if (cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1)

cMoneyStringBuffer.(cMoneyStringBuffer.length() - 1,

cMoneyStringBuffer.length());

cMoneyStringBuffer.append(fractionPart);

result = cMoneyStringBuffer.toString();

return result;

}

private String addUnitsToChineseMoneyString(String moneyStr) {

String result;

StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr);

int indexOfDot = cMoneyStringBuffer.indexOf(DOT);

cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN);

cMoneyStringBuffer.(cMoneyStringBuffer.length() - 1, JIAO);

cMoneyStringBuffer.(cMoneyStringBuffer.length(), FEN);

if (cMoneyStringBuffer.indexOf(“零角零分”) != -1)// 没有零头，加整

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零角零分”),

cMoneyStringBuffer.length(), “整”);

else if (cMoneyStringBuffer.indexOf(“零分”) != -1)// 没有零分，加整

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零分”),

cMoneyStringBuffer.length(), “整”);

else {

if (cMoneyStringBuffer.indexOf(“零角”) != -1)

cMoneyStringBuffer.(cMoneyStringBuffer.indexOf(“零角”),

cMoneyStringBuffer.indexOf(“零角”) + 2);

// tmpBuffer.append(“整”);

}

result = cMoneyStringBuffer.toString();

return result;

}

private void checkPrecision(String moneyStr) {//5336.53663 10-5-1

int fractionDigits = moneyStr.length() - moneyStr.indexOf(DOT) - 1;

if (fractionDigits >2)

throw new RuntimeException(“金额” + moneyStr + “的小数位多于两位。”); // 精度不能比分低

}

public static void main(String[] args) {

System.out.println(getInstance().format(new Double(8951.11)));

}

}

[java面试编程题]

篇6：java socket编程面试题

总结：

1) 建立Socket连接

2) 获得输入/输出流

3)读/写数据

4) 关闭输入/输出流

5) 关闭Socket

1. 编写一个网络应用程序，有客户端与服务器端，客户端向服务器端发送一个字符串，服务器收到该字符串后将其打印到命令行上，然后向客户端返回该字符串的长度，最后，客户端输出服务器端返回的该字符串的长度。

SockectServerTest

Java代码

import java.io.InputStream;

import java.io.OutputStream;

import java.net.ServerSocket;

import java.net.Socket;

public class SocketServerTest

{

public static void main(String[] args) throws Exception

{

ServerSocket ss = new ServerSocket(9999);

Socket socket = ss.accept();

InputStream is = socket.getInputStream();

OutputStream os = socket.getOutputStream();

byte[] buffer = new byte[100];

int length = is.read(buffer);

String content = new String(buffer,0,length);

System.out.println(“read from client:” + content);

int strLength = content.length();

String str = String.valueOf(strLength);

os.write(str.getBytes());

is.close();

os.close();

socket.close();

}

}

import java.io.InputStream;

import java.io.OutputStream;

import java.net.ServerSocket;

import java.net.Socket;

public class SocketServerTest

{

public static void main(String[] args) throws Exception

{

ServerSocket ss = new ServerSocket(9999);

Socket socket = ss.accept();

InputStream is = socket.getInputStream();

OutputStream os = socket.getOutputStream();

byte[] buffer = new byte[100];

int length = is.read(buffer);

String content = new String(buffer,0,length);

System.out.println(“read from client:” + content);

int strLength = content.length();

String str = String.valueOf(strLength);

os.write(str.getBytes());

is.close();

os.close();

socket.close();

}

}

ClientTest

Java代码

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

public class ClientTest

{

public static void main(String[] args) throws Exception

{

Socket socket = new Socket(“localhost”,9999);

InputStream is = socket.getInputStream();

OutputStream os = socket.getOutputStream();

String content = “This comes from client”;

os.write(content.getBytes());

byte[] b = new byte[100];

int length = is.read(b);

String str = new String(b,0,length);

System.out.println(“string's  length:” + str);

is.close();

os.close();

socket.close();

}

}

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

public class ClientTest

{

public static void main(String[] args) throws Exception

{

Socket socket = new Socket(“localhost”,9999);

InputStream is = socket.getInputStream();

OutputStream os = socket.getOutputStream();

String content = “This comes from client”;

os.write(content.getBytes());

byte[] b = new byte[100];

int length = is.read(b);

String str = new String(b,0,length);

System.out.println(“string's length:” + str);

is.close();

os.close();

socket.close();

}

}

[java socket编程面试题]

篇7：java编程思想读书笔记

对象具有状态,行为,标识.对象的五个基本特性:

万物皆对象,抽取待求解问题的任何概念化构件,将其表示为程序中的对象

程序是对象的集合,他们通过发送消息来告知彼此所要做的

每个对象都有自己的由其他对象所构成的存储,创建包含所有对象的包的方式来创建新类型的对象

每个对象都拥有其类型

某一特定类型的所有对象都可以接收同样的消息

1。java还有个“缺省”的访问权限，如果你没用public、protected、private的话，那就是指它了。通常把它称为package访问权限。因为同属这个package的类可以访问这个package中其它类的“缺省”权限的成员，但是出了这个package，它们就都是private的了。

2。多态性，处理类系的时候，通常你不用把它当作某个具体的类型，只要把它当作基类对象就可以了，即把泛型的基类当作派生类来用。非oop的编译器的做法是前绑定，即编译器会产生那个名字的函数调用，而连接器负责将这个调用解析成须执行的代码的绝对地址。oop的编译器用了后绑定，即当你向某个对象送了一个消息后，不到运行时，系统不能确定到底调用哪段代码。java用存储在对象中的信息来计算方法的地址，因此每个对象的运行都会不同。后绑定是java的缺省行为，c++中必须用virtual声明。

3。abstract关键词声明类为抽象类，编译器会阻止任何人创建abstract类的对象，而只是把其派生类的对象上传给它。abstract也可以声明方法，表示这个类所派生的所有类都有这个方法，但是它的实现不在这里。abstract方法只能存在于abstract类中。

4。interface关键词是对abstract类的概念的深化，它不允许你实现任何方法，只作为接口使用.可以继承多个接口，java中无类多重继承。

5。c++支持的变量有自动、静态、寄存器和堆，java只支持堆变量，每次创建对象的时候都要用new来动态分配堆内存。

6。容器和迭代器：容器：c++标准模板类库stl = java标准类库的容器类，迭代器：将基于不同数据结构的容器抽象为一个简单线性序列的类。

7。java是单根继承体系，object作为最终基类使所有对象都具有某些基本操作。单根继承和系统通过reference操控对象，使垃圾回收器可以释放堆内存。

8。java容器只持有object对象，单根继承使它能持有任何对象上传只要把对象的reference直接放入即可，取对象时，必须知道它原有的类型，从容器中取出对象的reference然后强制转换为原因类型(下传：由基类到其派生类)。

9。参数化类型：能够根据需要由编译器自动指派类型的类，c++的模板template即参数化类型。java暂不支持

10。异常是一种能从错误发生的地方被抛出的对象，并被能解决这类问题的异常处理程序所捕获，异常肯定能得到处理，并且能够从错误状态下恢复。java的异常处理是从底层开始的，而且还不能不用，否则就不能编译通过。

11。java语音内置了多线程支持，线程被表示为对象，java还有一定的资源锁定功能,可以通过synchronized关键字锁定对象内存。

12。持久性：java可以通过对象的序列化或java数据对象来实现把对象从磁盘中存储和提取。

13。传统w/s：浏览器上送web服务器的数据由web服务器上的通用网关接口程序CGI处理，常用语言perl、python、C++等。

14。客户端编程：插件：可以为浏览器添加新的功能，甚至创造新的客户端编程语言。脚本语言：把客户端的源代码直接嵌入到html页面中，html页面显示的时候自动激活插件解释这些程序。常用脚本语言javascript、vbscript、tcl/tk等。java：可以通过applet和java web start进行客户端编，applet是一个只能运行在web浏览器里的小程序，applet是被编译过的代码，作为web页面的一部分自动下载，在被激活的时候开始运行。java web start分发在web浏览器外运行的独立程序。Activex操作上不受限制。

15。servlet和jsp是使人们转向使用java开发网站的主要原因。

篇8：java编程思想读书笔记

《Java编程思想》学习笔记

1――面向对象和JVM基础

1.java中的4种访问制权限：

(1).public：最大访问控制权限，对所有的类都可见。

(2).protect：同一包可见，不在同一个包的所有子类也可见。

(3).default：包访问权限，即同一个包中的类可以可见。默认不显式指定访问控制权限时就是default包访问控制权限。

(4).private：最严格俄访问控制权限，仅该类本身可见，对外一切类都不可以访问(反射机制可以访问)。

2.面向对象编程中两种对象组合方式――is-a 和 has-a：

(1).is-a组合：一个类继承具有相似功能的另一个类，根据需要在所继承的类基础上进行扩展。

优点：具有共同属性和方法的类可以将共享信息抽象到父类中，增强代码复用性，同时也是多态的基础。

缺点：子类中扩展的部分对父类不可见，另外如果共性比较少的时候使用继承会增加冗余代码。

(2).has-a组合：has-a组合是在一个类中引用另一个类作为其成员变量。 优点：可扩展性和灵活性高。在对象组合关系中应优先考虑has-a组合关系。 缺点：具有共性的类之间看不到派生关系。

3.多态：

在面向对象编程中，子类中拥有和父类相同方法签名的方法称为子类方法覆盖父类方法，当调用子类方法的某个操作时，不必明确知道子类的具体类型，只需要将子类类型看作是父类的引用调用其操作方法，在运行时，JVM会根据引用对象的具体子类类型而调用应该的方法，这就是多态。

多态的基础是java面向对象编程的晚绑定机制。编程中有如下两种绑定机制：

(1).早绑定：一般在非面向对象编程语言中使用，在程序编译时即计算出具体调用方法体的内存地址。

(2).晚绑定：面向对象编程语言中经常使用，在程序编译时无法计算出具体调用方法体的内存地址，只进行方法参数类型和返回值类型的校验，在运行时才能确定具体要调用方法体的内存地址。

4.java单继承的优点：

相比于C++的多继承，java只支持类的单继承，java中的所有类的共同基类是Object类，Object类java类树的唯一根节点，这种单继承有以下好处：

(1).单继承可以确保所有的对象拥有某种共同的特性，这样对于JVM虚拟机对所有的类进行系统级的操作将提供方便，所有的java对象可以方便地在内存堆栈中创建，传递参数也变的更加方便简单。

(2).java的单继承使得实现垃圾回收器功能更加容易，因为可以确保JVM知道所有对象的类型信息。

5.选择容器对象两个原则：

(1).容器所能提供不同的类型的接口和外部行为是否能够满足需求。

(2).不同容器针对不同的操作效率不同。

6.类型转换：

Java中有两种常见的类型转换：向上类型转换(upcast)和向下类型转换(downcast)：

(1).向上类型转换(upcast)：

向上类型转换是将子类对象强制类型转换为父类类型，经典用法是面向对象的多态特性。向上类型转换时，子类对象的特性将不可见，只有子类从父类继承的特性仍然保持可见，向上类型转换时编译器会自动检查是否类型兼容，通常是安全的。

(2).向下类型转换：

向下类型转换是将父类类型强制转换为子类类型，转换过后父类中不可见的子类特性又恢复可见性，向下类型转换时，编译器无法自动检测是否类型兼容，往往会产生类型转换错误的运行时异常，通常不安全。

7.java中5个存放数据的地方：

(1).寄存器(Registers)：位于CPU内部，是速度最快的存储区，但是数量和容量有限。在java中不能直接操作寄存器。

(2).栈(Stack)：栈位于通用随机访问存储器 (General random-access memory，RAM，内存) 中，通过处理器的栈指针访问，栈指针从栈顶向栈底分配内存，从栈底向栈顶释放内存。栈是仅次于寄存器的速度第二快的存储器，在java程序中，一般的8种 基本类型数据和对象的引用通常存放在栈内存中，不通过new关键字的字符串对象也是存放在栈的字符串池中。栈的优势是，存取速度比堆要快，仅次于寄存器， 栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。

(3).堆(Heap)：也是位于通用随机访问存储器 (General random-access memory，RAM，内存) 中的共享内存池。Java的堆是一个运行时数据区，类的对象从中分配空间，凡是通过new关键字创建的对象都存放在堆内存中，它们不需要程序代码来显式的 释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器 会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

(4).常量存储器(Constant storage)：java中的常量是存放在系统内嵌的只读存储器中(read-only memory,ROM)的。

(5).非随机存储器(Non-RAM storage)：对于流对象和持久化对象，通常存放在程序外的存储器，如硬盘。

8.javadoc只处理public和protected访问控制权限的文档注释，private和default权限的稳定注释将被忽略。

9.java中赋值运算：

基本类型赋值是直接复制值，赋值操作后，相互不影响。

引用类型赋值是复制引用值，相当于给对象取一个别名，赋值之后两个引用指向同一个引用对象，相互之间有影响。

在Java中，向方法传递引用类型参数会改变参数的值，不让参数受到影响的解决方法：在方法内首先先将引用克隆一份，然后操作克隆的对象。

10.移位运算：

左移运算符<<：将比特位左移指定位数，右边部分补0，左移一位相当于乘2。

右移运算符>>：将比特位右移指定位数，如果是正数，左边第一位(符号位)补0，其余位补0，如果是负数，左边第一位补1，其余位补0。右移一位相当于除2。

无符号右移运算符>>>：将比特位右移指定位数，不论是正数或者负数，左边移除位统统补0。

11.java中，比int类型小的原始类型(char、byte、short)进行数学运算或者位运算时，数据类型首先转换成int类型，然后进行相应的运算。

12.方法重载(overloading)：方法同名，参数列表不同称为方法重载，注意方法的返回值类型不同不能作为方法重载。

13.java中的析构函数：

Java中没有像C/C++的析构函数，用来销毁不用的对象是否内存空间，只有以下三个方法用于通知垃圾回收器回收对象。

(1).finalize( )只是通知JVM的垃圾收集器当前的对象不再使用可以被回收了，但是垃圾回收器根据内存使用状况来决定是否回收。

finalize最有用的地方是在JNI调用本地方法时(C/C++方法)，调用本地方法的析构函数消耗对象释放函数。

(2). System.gc()是强制析构，显式通知垃圾回收器释放内存，但是垃圾回收器也不一定会立即执行，垃圾回收器根据当前内存使用状况和对象的生命周期自行决定是否回收。

(3).RunTime.getRunTime().gc()和System.gc()类似。

注意：这三个函数都不能保证垃圾回收器立即执行，推荐不要频繁使用。

14.垃圾回收器原理：

(1).引用计数(ReferenceCounting)垃圾回收算法：

一种简单但是速度较慢的垃圾回收算法，每个对象拥有一个引用计数器

(Reference Counter)，当每次引用附加到这个对象时，对象的引用计数器加1。当每次引用超出作用范围或者被设置为null时，对象的引用计数器减1。垃圾回收 器遍历整个对象列表，当发现一个对象的引用计数器为0时，将该对象移出内存释放。

引用计数算法的缺点是，当对象环状相互引用时，对象的引用计数器总不为0，要想回收这些对象需要额外的处理。

引用计数算法只是用来解释垃圾回收器的工作原理，没有JVM使用它实现垃圾回收器。

引用计数的改进算法：

任何存活的对象必须被在静态存储区或者栈(Stack)中的引用所引用，因此当遍历全部静态存储区或栈中的引用时，即可以确定所有存活的对象。每当 遍历一个引用时，检查该引用所指向的对象，同时检查该对象上的所有引用，没有引用指向的对象和相互自引用的对象将被垃圾回收器回收。

(2).暂停复制(stop-and-copy)算法：

垃圾回收器的收集机制基于：任何一个存活的对象必须要被一个存储在栈或者静态存储区的引用所引用。

暂停复制的算法是：程序在运行过程中首先暂停执行，把每个存活的对象从一个堆复制到另一个堆中，已经不再被使用的对象被回收而不再复制。 暂停复制算法有两个问题：

a.必须要同时维护分离的两个堆，需要程序运行所需两倍的内存空间。JVM的解决办法是在内存块中分配堆空间，复制时简单地从一个内存块复制到另一个内存块。

b.第二个问题是复制过程的本身处理，当程序运行稳定以后，只会产生很少的垃圾对象需要回收，如果垃圾回收器还是频繁地复制存活对象是非常低性能的。

JVM的解决方法是使用一种新的垃圾回收算法――标记清除(mark-and-sweep)。 一般来说标记清除算法在正常的使用场景中速度比较慢，但是当程序只产生很少的垃圾对象需要回收时，该算法就非常的高效。

(3).标记清除(mark-and-sweep)算法：

和暂停复制的逻辑类似，标记清除算法从栈和静态存储区开始追踪所有引用寻找存活的对象，当每次找到一个存活的对象时，对象被设置一个标记并且不被回收，当标记过程完成后，清除不用的死对象，释放内存空间。

标记清除算法不需要复制对象，所有的标记和清除工作在一个内存堆中完成。

[java编程思想读书笔记]

篇9：怎么才能有效学习java编程

学习java编程的建议

1明确面向对象的范畴

我们必须明确一个大方向，也就是说现在面向对象的编程范畴。尽管人工智能曾经有所浪潮(看看Borland为什么有Turbo Prolog)，但未来5-工业界广泛承认并接受的将是面向对象式的编程。

工业界目前最流行的面向对象编程语言就是C++和Java。所以基本上锁定这两个方向就可以了。而且完全可以同时掌握。

2掌握Java的精华特性

掌握Java的精华特性的同时，一定要知道为什么。比如，Interface和multi-thread。用interface是更好的多继承的模型，而多线程则是设计到语言一级的重要特性。要完全理解interface是为什么，用多线程又有几种常用的编程模型。

3开始进行设计

理解了语言的特性是为什么了之后，就可以试着上升到设计这个层次，毕竟学习语言是要用的。目前比较好的开发模式是采用自定向下的面向对象的设计，加上MVC的模式(你可以看一下我介绍的关于MVC的内容)。首先要找出最顶层的对象(这往往是最难的)，然后一层一层往下递归，记住每次应符合7+/-2的原则，因为我们人的短记忆就是这样。一般有图形用户界面的应从界面开始设计。

4学习设计模式

有了基本设计模型后，可以学一些设计模式(Design Pattern)。这是目前证明很有效的。比如体系结构模式(Layering分层，Pipe/Filter管道或过滤器)，设计模式(有很多，比如对象池Object Pool、缓冲池Cache等)，编程模式(比如Copy-on-Write)。

懂了这些模式之后，就会对系统的整体结构有很好的把握，而学术上也有倾向一个系统完全可以由各种模式组合而成。前面提到的MT实际上就有好几种模式，掌握后就不用自己花很多时间去试了。另外一个很重要的领域就是并行和分布式计算领域，大概有20种左右。

5进行编程实践

接下来就不能纸上谈兵了，最好的方法其实是实践。一般教科书上的例子并不能算是实践，只能算是让你掌握语言特性用的。而提倡做实际的Project也不是太好，因为你还没有熟练的能力去综合各种技术，这样只能是你自己越来越迷糊。

我认为比较好的方法是找一些比较经典的例子，每个例子比较集中一种编程思想而设计的，比如在我的实践当中，我曾经学习过一个很经典的例子就是用Java实现的HotDraw(源自SmallTalk)，你可以用rolemodel或hotdraw在搜索引擎上找一下，我记不大清楚了。好象是个网站，上面有原代码和一些基本设计的文档。

另一个来源可以到是个不错的文档基地。从HotDraw上我学到了什么是Framework，以及如何用rolemodel的方式来构造，这样我就可以应用到其他的地方。顺便说一句，这个例子你绝对不会觉得小，只会觉得大，并且他还是真正的商用的Framework。

零基础怎么学Java

理解Java思想

Java是一门面向对象编程语言。向对象编程是Java最核心的思想，这也是区分和C等其他编程语言的一个显著特征。掌握面一门语言，首先得掌握它的思想，思想决定高度。这就和我们学习语文和英语一样，汉语学拼音，英语学音标。抓住了核心，学习起来就事半功倍。

弄清基本概念

作为一门语言，Java肯定有着丰富而又简单的概念。弄清这些基本概念也是必不可少的，死记硬背肯定是不行的，重在理解，理解它们之间的区别与联系，分别有那些应用。有些同学打开电脑就照着书本敲代码，根本没有想过这些代码中用到了哪些知识点，更谈不上理解了，这样是没有任何效果的。

多练习

只理解了Java的基本概念是远远不止的，还要知道怎么去使用。刚开始，你可能会觉得Java中那么多东西怎么也记不住，就连写一个小小的入门级程序都要涉及到好多东西。但是，当你亲手在键盘上敲了几遍之后，你就会觉得之前的那些问题都不是问题了。

学会帮助看文档与源代码

Java是一门开放源代码的编程语言。利用网络可以下载官方的帮助文档，当你不知道一个东西怎么用时，你可以打开帮助文档，你的问题一下就解决了。如果还不能解决的话，打开搜索引擎，输入你的问题，你一定会找到答案的。如果你想弄懂Java底层的原理的话，可以去网上下载对应的源代码。看了源代码之后，你会发现Java的世界是多么的奇妙，也会提高你Java编程的水平。

掌握一种好的而且适合自己的学习方法很重要。有些同学在学习Java的过程中会陷入误区，下面将给大家列出初学者容易进入的误区。

学习java编程的注意事项

盲目追求速度，不重代码质量

速度很重要，但代码质量更重要。一个在追求速度而不注重代码质量的环境下完成的项目，肯定是会有很多问题的，后期要花更多的人力物力来弥补，得不偿失。

没有团队精神，过于自我

一个项目不可能由一个人来独立完成，而是由团队里不同角色的人来共同合作完成的。个人的力量是渺小的，团队的力量是无穷的。当你的队友遇到问题时，如果你能解决，你要不吝帮助。同样，你有问题时，你的队友也会及时帮助你。

没有开源精神

一门技术，如果它是开源的话，它就会变得越来越成熟。当你写了一段团队里都能通用的程序时，你可以告诉你的团队，节省开发的时间，也创造了别人给你提出问题的环境，让你的代码更加完善。

给你的代码写上必要的注释也是非常重要的，好多人写程序时都不愿意写注释，给的理由是没必要或者是时间太紧，试想一下，如果当你正在阅读或者修改一段没有注释的代码时候，你是不是会觉得弄懂它的意思很难，当然你可以花更多的时间去弄懂它，但如果你加了注释的话，就完全没有必要花费更多的时间了。

总之，Java是一门容易上手的编程语言，但想要融会贯通，除了掌握良好的学习方法之外，努力是必不可少的。学习java要对自己有充分的信心，调整学习方法和态度。

篇10：数控编程简历

本文由大学生简历网（）为您提供以下相关内容、求职简历空白表格        求职简历模板下载 ：作为参考

为了让你了解写个人简历时能写得更好下面文章为写求职简历时作为模板、物业管理人员个人简历范文      景观设计个人简历范文。

篇11：软件编程简历

熟练PHOTOSHOP，CORELDRAW，ILLUSTRATOR图形设计处理软件；

熟练DREAMWEAVER制作网页、MICROMEDIA FLASH MX制作动画；

熟练ZINEMAKE软件制作电子杂志、AUTHORWARE多媒体软件的使用；

熟练DELPHI可视化编程软件，C语言编程软件，VISUAL C++语言编程软件；

熟练SQL SERVER2000数据库管理软件，MATLAB编程处理、计算复杂函数；

熟练互联网的应用，了解电子商务，能够有效利用互联网资源；

熟练WINDOWS，能够熟练使用WORD，POWERPOINT等OFFICE软件。  

篇12：VB编程简历

基本资料

姓 名：  性 别： 男 出生年月： 1988-12-05

婚姻状况： 未婚 政治面貌： 团员 民 族：汉族

身 高： 176 体 重： 60 最高学历： 本科

职 称：  毕业学校： 广东教育学院

毕业时间： 2011-06-07 特长概括：沟通、协调、演讲

户 籍： 广东惠州市

现所在地： 广东惠州市

自我评价

具备日本语的听、说、读写能力，并取得相关证书，普通话、粤语标准；能熟练使用计算机、系统维护、硬件维护、能熟练使用DOS、WINDOWS系统，并熟练排除计算机软硬故障；熟悉网络应用。自学能力强 。适应力强，反应快、积极、灵活，爱创新！提高自己，适应工作的需要。在学习中，我注重理论与实践的结合，己具备了相当的实践操作能力 。具有很强的事业心和责任感使我能够面对任何困难和挑战，所以我希望找一份与自身知识结构相关的工作，如,文员,助理可以有更大的空间来证明自己，发展自己！

求职意向

工作岗位： 计算机硬件、信息技术专员、售前/售后技术支持工程师,营销-技术服务及客服售后/客服主管（非技术）,教师小学教育（英语）,教师中等教育（外语）

职位性质： 全职 行业类别： 商业贸易/物流仓储/经纪代理,教育/培训

工作地区： 广东省深圳市龙岗区 到岗时间： 随时 月薪要求： 2500～3500元

其他要求：

教育

学历 学校名称 专业 时间范围 专业描述

不限 广东教育学院 外语类英语 2008年11月-0年0月

培训描述：

语言 外语语种 掌握程度   国家英语测试4级

工作经验

2007年7月-2007年9月 ：增城市绣花厂

公司性质： 民营企业 所属行业： 其他行业

所在部门：  担任职务： 助理

工作描述： 作为绣花厂的一名助理，其日常工作主要是负责货物的进出，有时候帮助老板处理一下文件，

离职原因： 返校

技能专长

主修课程：

《程序设计》、C++等计算机课程，掌握模拟电路、数字电路、计算机应用基础、计算机网络

多媒体技术应用、VB编程技术

网页编程及设计、现代教育技术理论

数据库设计及应用

1、扎实的计算机操作能力，熟悉PC软/硬件、安监系统、公司电话系统及网络的`安装及维护，能充分利用现有资源为公司创造应有的效益；

2、统筹规划公司的办公耗材，节省成本；

3、工作踏实、仔细认真。

相关证书

职场风采

个人特点：

学习方面：专业础扎实，计算机操作及网络管理能力完善；

生活方面：能吃苦耐劳，有较强的适应能力；

个性方面：乐观直爽、开朗大方，时间观念强；

工作方面：负责守信、严密踏实。

工作地点：广州、东莞、深圳

编程简历

java简历

JAVA程序员的简历

java高级工程师简历

数控编程员简历

JAVA编程简历.doc

将本文的Word文档下载到电脑，方便收藏和打印

推荐度：

点击下载文档