1、Java 实例 – 数字求和运算：使用do...while结构求0~100的整数数字之和
public class DateStr_Sum {
public DateStr_Sum() {
int limit=100;
int sum=0;
int i=1;
do {
sum=sum+i;
i++;
}while(i<=limit);
System.out.println("0~100的整数数字之和:"+sum);
}
}
运行结果：
2、Java 实例 – 利用堆栈将中缀表达式转换成后缀：
public class Stack {
private int maxSize;
private char[]stackArray;
private int top;
public Stack(int max) {
maxSize = max;
stackArray =new char[maxSize];
top = -1;
}
public void push(char j) {
stackArray[++top] = j;
}
public char pop() {
return stackArray[top--];
}
public char peek() {
return stackArray[top];
}
public boolean isEmpty() {
return (top == -1);
}
}
·····························································································
public class DateStr_StackTransform {
private StacktheStack;
private Stringinput;
private Stringoutput ="";
public DateStr_StackTransform(String in) {
input = in;
int stackSize =input.length();
theStack =new Stack(stackSize);
}
public String doTrans() {
for (int j =0; j
char ch =input.charAt(j);
switch (ch) {
case '+':
case '-':
gotOper(ch,1);
break;
case '*':
case '/':
gotOper(ch,2);
break;
case '(':
theStack.push(ch);
break;
case ')':
gotParen(ch);
break;
default:
output =output + ch;
break;
}
}
while (!theStack.isEmpty()) {
output =output +theStack.pop();
}
//System.out.println(output);
return output;
}
public void gotOper(char opThis,int prec1) {
while (!theStack.isEmpty()) {
char opTop =theStack.pop();
if (opTop =='(') {
theStack.push(opTop);
break;
}
else {
int prec2;
if (opTop =='+' || opTop =='-')
prec2 =1;
else
prec2 =2;
if (prec2 < prec1) {
theStack.push(opTop);
break;
}
else
output =output + opTop;
}
}
theStack.push(opThis);
}
public void gotParen(char ch){
while (!theStack.isEmpty()) {
char chx =theStack.pop();
if (chx =='(')
break;
else
output =output + chx;
}
}
public static void main(String[] args)
throws IOException {
String input ="1+2*4/5-7+3/6";
String output;
DateStr_StackTransform theTrans =new DateStr_StackTransform(input);
output = theTrans.doTrans();
System.out.println("中缀式："+input);
System.out.println("后缀式：" + output +'\n');
}
}
运行结果：
3、Java 实例 – 在链表（LinkedList）的开头和结尾添加元素：使用 LinkedList 类的 addFirst() 和 addLast() 方法在链表的开头和结尾添加元素。
public class DateStr_LinklistAdd {
public DateStr_LinklistAdd() {
LinkedList lList =new LinkedList();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println("原链表："+lList);
lList.addFirst("0");
System.out.println("头部添加："+lList);
lList.addLast("6");
System.out.println("尾部添加："+lList);
}
}
运行结果：
4、Java 实例 – 获取链表（LinkedList）的第一个和最后一个元素：使用 LinkedList 类的 linkedlistname.getFirst() 和 linkedlistname.getLast() 来获取链表的第一个和最后一个元素。
public class DateStr_LinklistGet {
public DateStr_LinklistGet() {
LinkedList lList =new LinkedList();
lList.add("100");
lList.add("200");
lList.add("300");
lList.add("400");
lList.add("500");
System.out.println("链表元素有："+lList);
System.out.println("链表的第一个元素是：" + lList.getFirst());
System.out.println("链表的最后一个元素是：" + lList.getLast());
}
}
运行结果：
5、Java 实例 – 删除链表中的元素：使用 clear() 方法来删除链表中的元素。
public class DateStr_LinklistDelete {
public DateStr_LinklistDelete() {
LinkedList lList =new LinkedList();
lList.add("1");
lList.add("8");
lList.add("6");
lList.add("4");
lList.add("5");
System.out.println("原链表："+lList);
lList.subList(2,4).clear();//2之后是起始删除位置，4是结束位置
System.out.println("删除后链表："+lList);
}
}
运行结果：
6、Java 实例 – 获取链表的元素：使用 top() 和 pop() 方法来获取链表的元素。
public class DateStr_LinklistLookup {
public DateStr_LinklistLookup() {
for (int i =30; i <40; i++)
push(new Integer(i));
System.out.print(top()+" ");
System.out.print(pop()+" ");
System.out.print(pop()+" ");
System.out.println(pop());
}
private LinkedListlist =new LinkedList();
public void push(Object v) {
list.addFirst(v);
}
public Object top() {
return list.getFirst();
}
public Object pop() {
return list.removeFirst();
}
}
运行结果：
7、Java 实例 – 获取向量元素的索引值：使用 Collections 类的 sort() 方法对向量进行排序并使用 binarySearch() 方法来获取向量元素的索引值。
public class DateStr_VectorKey {
public DateStr_VectorKey() {
Vector v =new Vector();
v.add("X");
v.add("M");
v.add("D");
v.add("A");
v.add("O");
Collections.sort(v);
System.out.println("向量中的元素有："+v);
int index = Collections.binarySearch(v,"D");
System.out.println("元素D的索引值为 : " + index);
}
}
运行结果：
8、Java 实例 – 栈的实现：通过创建用于插入元素的自定义函数 push() 方法和用于弹出元素的 pop() 方法来实现栈。
public class DateStr_Stack {
private int maxSize;
private char[]stackArray;
private int top;
public DateStr_Stack(int max) {
maxSize = max;
stackArray =new char[maxSize];
top = -1;
push('1');
push('2');
push('3');
push('4');
push('5');
System.out.println("栈元素有：");
while (!isEmpty()) {
long value = pop();
System.out.print(value);
System.out.print(" ");
}
System.out.println("");
}
public void push(char j) {
stackArray[++top] = j;
}
public char pop() {
return stackArray[top--];
}
public char peek() {
return stackArray[top];
}
public boolean isEmpty() {
return (top == -1);
}
}
运行结果：
9、Java 实例 – 链表元素查找：使用 linkedlistname.indexof(element) 和 linkedlistname.Lastindexof(elementname) 方法在链表中获取元素第一次和最后一次出现的位置。
public class DateStr_LinklistFind {
public DateStr_LinklistFind() {
LinkedList lList =new LinkedList();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
lList.add("2");
System.out.println("链表元素有："+lList);
System.out.println("元素 2 第一次出现的位置：" + lList.indexOf("2"));
System.out.println("元素 2 最后一次出现的位置："+ lList.lastIndexOf("2"));
}
}
运行结果：
10、Java 实例 – 压栈出栈的方法实现字符串反转：使用用户自定义的方法 StringReverserThroughStack() 来实现字符串反转。
public class Stack {
private int maxSize=20;
private char[]stackArray;
private int top;
public Stack() {
stackArray =new char[maxSize];
top = -1;
while (!isEmpty()) {
long value = pop();
System.out.print(value);
System.out.print(" ");
}
System.out.println("");
}
public void push(char j) {
stackArray[++top] = j;
}
public char pop() {
return stackArray[top--];
}
public char peek() {
return stackArray[top];
}
public boolean isEmpty() {
return (top == -1);
}
}
··············································································
public class DateStr_StackReverse {
private Stringinput ="www.jwkschool.cc";
private Stringoutput;
public DateStr_StackReverse()throws IOException {
String output;
output = doRev();
System.out.println("反转前： " +input);
System.out.println("反转后： " + output);
}
public String doRev() {
int stackSize =input.length();
Stack theStack =new Stack();
for (int i =0; i
char ch =input.charAt(i);
theStack.push(ch);
}
output ="";
while (!theStack.isEmpty()) {
char ch = theStack.pop();
output =output + ch;
}
return output;
}
}
运行结果：
11、Java 实例 – 队列（Queue）用法：队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。LinkedList类实现了Queue接口，因此可以把LinkedList当成Queue来用。
public class DateStr_Queue {
public DateStr_Queue() {
//add()和remove()方法在失败的时候会抛出异常(不推荐)
Queue queue =new LinkedList(); //添加元素
queue.offer("a");
queue.offer("b");
queue.offer("c");
queue.offer("d");
queue.offer("e");
for(String q : queue){
System.out.print(q+" ");
}
System.out.println("`````````````````");
System.out.println("poll="+queue.poll());//返回第一个元素，并在队列中删除
for(String q : queue){
System.out.print(q+" ");
}
System.out.println("\n`````````````````");
System.out.println("element="+queue.element());//返回第一个元素
for(String q : queue){
System.out.print(q+" ");
}
System.out.println("\n`````````````````");
System.out.println("peek="+queue.peek());//返回第一个元素
for(String q : queue){
System.out.print(q+" ");
}
}
}
运行结果：
12、Java 实例 – 获取向量的最大元素：使用 Vector 类的 v.add() 方法及 Collection 类的 Collections.max() 来获取向量的最大元素。
public class DateStr_VectorGetMax {
public DateStr_VectorGetMax() {
Vector v =new Vector();
v.add(new Double("3.4324"));
v.add(new Double("3.3532"));
v.add(new Double("3.342"));
v.add(new Double("3.349"));
v.add(new Double("2.3"));
Object obj = Collections.max(v);
System.out.println("向量中的元素有："+v);
System.out.println("最大元素是："+obj);
}
}
运行结果：
13、Java 实例 – 链表修改：使用 listname.add() 和 listname.set() 方法来修改链接中的元素。
public class DateStr_LinklistUpdate {
public DateStr_LinklistUpdate() {
LinkedList officers =new LinkedList();
officers.add("B");
officers.add("B");
officers.add("T");
officers.add("H");
officers.add("P");
System.out.println("原链表："+officers);
officers.set(2,"M");
System.out.println("新链表："+officers);
}
}
运行结果：
14、Java 实例 – 旋转向量：使用 swap() 函数来旋转向量。
public class DateStr_VectorRevolve {
public DateStr_VectorRevolve() {
Vector v =new Vector();
v.add("1");
v.add("2");
v.add("3");
v.add("4");
v.add("5");
System.out.println("原向量："+v);
Collections.swap(v,0,4);
System.out.println("旋转后："+v);
}
}
运行结果：
网友评论