java程序设计基础

数据结构

栈stack

实现：链表：表的顶端LIFO,插入push，弹出pop

           数组：空栈topOfStack初始化-1；插入，topOfStack加1,theArray[topOfStack]=x;弹出，返回值theArray[topOfStack]，                                topOfStack减1

1.消除尾递归：将代码放到一个while循环中，用每个方法参数的一次赋值代替递归调用

2.中缀转后缀：操作数放到output中。操作符放到栈中，当前操作符放入栈之前，只要它优先级小于或等于栈顶操作符，栈顶操作符被弹出到output中，它被压入栈中。左括号优先级最高放入栈中，重复上述，直到读到右括号，将栈元素中的操作符直到左括号弹出到output，左右括号不放入output中。输入为空，将栈中操作符全部弹出到output。

 

队列queue

实现：链表&数组，enqueue队尾入队，dequeue队头出队

           数组实现：数组theArray，两端位置front和back，元素个数currentSize

                   元素x入队： currentSize和back加1，theArray[back]=x

                   元素出队：返回值theArray[front]， currentSize减1，front加1

           循环数组：只要front或back到达数组尾端回绕到对头。

 

程序设计基础

 

Enumeration接口：使用在Vector和Propertie，这种传统接口已被迭代器取代，

boolean hasMoreElements( ) 测试此枚举是否包含更多的元素；

Object nextElement( )如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素

 

String类:不可改变,管理者

length()	静态方法format()创建可复用的格式化字符串
'+'操作符来连接字符串	int compareTo()  int compareToIgnoreCase()
char charAt(int index)	boolean endsWith(String suffix) boolean equalsIgnoreCase(String anotherString) String[] split(String regex)
boolean equals() boolean equalsIgnoreCase()	int indexOf()、int lastIndexOf()
String replace(char oldChar, char newChar)	String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
String[] split(String regex)	String substring(int beginIndex, int endIndex)
char[] toCharArray() void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。	String toLowerCase() String toUpperCase()

String fs;

fs = String.format("The value of the float variable is " + "%f, while the value of the integer "

                             + "variable is %d, and the string " + "is %s", floatVar, intVar, stringVar);

System.out.println(fs);

 

StringBuffer和StringBuilder类:对象能够被多次的修改，并且不产生新的未使用对象;单任务访问，StringBuilder有速度优势；多任务访问，在应用程序要求线程安全的情况下，则必须使用StringBuffer类

public StringBuffer append(String s) 将指定的字符串追加到此字符序列。

public StringBuffer reverse()  将此字符序列用其反转形式取代。

public delete(int start, int end) 移除此序列的子字符串中的字符。

public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。

replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

遍历：

String s = in.nextaLine();

StringBuilder  stringbuilder =  new StringBuilder();

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

if(Character.isLetterOrDigit(s.charAt(i))){

    stringBuilder.append(s.charAt(i));

}

}

 

 

数组：Java数组不能增长；创建一个可扩展的数组使用ArrayList或Vector

           dataType[] arrayRefVar;

          arrayRefVar = new dataType[arraySize];//索引值从0到arrayRefVar.length-1

          遍历：for (double element: myList) {          System.out.println(element);       }

 

Arrays类：实现数组的排序查找、数组的比较和填充数组元素以及返回数组的字符串表示

                              java.util.Arrays.方法名（数组名）

public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。

public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

 

ArrayList类：存储不限定个数的对象，是泛型类，具有泛型类型E，不能使用基本数据类型来代替泛型类型;

ArrayList<AConcreteType> list = new ArrayList<>();

list.add(new Integer(10));     list.add([index,]object);     list.remove(object/index);     list.get(index);

list.size();   list.clear();     list.contains(object);     list.set(index,E);

遍历：for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); }

 

Vector类：实现了一个动态数组，可以改变大小，是同步访问的

Vector v = new  Vector()   

Vector(int size)    

Vector(int size,int incr) //增量incr指定，向量每次增加的元素数目

Vector(Collection c)

int capacity()  返回此向量的当前容量。	void add(int index, Object element)   在此向量的指定位置插入指定的元素。
	void addElement(Object obj)   将指定的组件添加到此向量的末尾
boolean contains(Object elem)  如果此向量包含指定的元素，则返回 true。	void insertElementAt(Object obj, int index)  将指定对象作为此向量中的组件插入到指定的 index 处

           遍历：

          1.  //Enumeration elements() 返回此向量的组件的枚举

Enumeration vEnum = v.elements();

while(vEnum.hasMoreElements())

       System.out.print(vEnum.nextElement() + " "); 

 

      2.  for (int i = 0; i < v.size(); i++) {
            System.out.print(v.get(i));    
        }
        
       3. Iterator<String> it = v.iterator();
        while (it.hasNext()) {
            String string = (String) it.next();
            System.err.print(string);
        }

 

 Stack 类:栈是Vector的一个子类，后进先出；

        Stack st = new Stack();

boolean empty()  测试堆栈是否为空。

Object peek( ) 查看堆栈顶部的对象，但不从堆栈中移除它。

Object pop( ) 移除堆栈顶部的对象，并作为此函数的值返回该对象。

Object push(Object element) 把项压入堆栈顶部。

int search(Object element) 返回对象在堆栈中的位置，以 1 为基数。

 

Map 接口：键和值一一映射. 可以通过键来获取值

      Map m1 = new HashMap();

void clear( )从此映射中移除所有映射关系（可选操作）。

boolean containsKey(Object k)如果此映射包含指定键的映射关系，则返回 true。

boolean containsValue(Object v)如果此映射将一个或多个键映射到指定值，则返回 true。

Set entrySet( )返回此映射中包含的映射关系的 Set 视图。

boolean equals(Object obj)比较指定的对象与此映射是否相等。

Object get(Object k)返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

int hashCode( )返回此映射的哈希码值。

boolean isEmpty( )如果此映射未包含键-值映射关系，则返回 true。

Set keySet( )返回此映射中包含的键的 Set 视图。

Object put(Object k, Object v)将指定的值与此映射中的指定键关联（可选操作）。

void putAll(Map m)从指定映射中将所有映射关系复制到此映射中（可选操作）。

Object remove(Object k)如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

int size( )返回此映射中的键-值映射关系数。

Collection values( )返回此映射中包含的值的 Collection 视图。

 

Hashtable 接口 ：支持同步，在哈希表中存储键/值对；当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值，然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

Hashtable(int size)    

Hashtable(int size,float fillRatio) //填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度

Hashtable(Map m)//以M中元素为初始化元素的哈希表，哈希表的容量被设置为M的两倍。

Hashtable中除了从Map接口中定义的方法外，还定义了以下方法：

Object clone( )创建此哈希表的浅表副本。

boolean contains(Object value) 测试此映射表中是否存在与指定值关联的键。

boolean containsKey(Object key)测试指定对象是否为此哈希表中的键。

boolean containsValue(Object value)如果此 Hashtable 将一个或多个键映射到此值，则返回 true。

Enumeration elements( )返回此哈希表中的值的枚举。

Object get(Object key)返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null.

boolean isEmpty( )测试此哈希表是否没有键映射到值。

Enumeration keys( )返回此哈希表中的键的枚举。

Object put(Object key, Object value)将指定 key 映射到此哈希表中的指定 value。

void rehash( )增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。

Object remove(Object key)从哈希表中移除该键及其相应的值。

int size( )返回此哈希表中的键的数量。

String toString( )返回此 Hashtable 对象的字符串表示形式

遍历：

Hashtable balance = new Hashtable();

balance.put("Zara", new Double(3434.34));

Enumeration names;

names = balance.keys();

String str;

while(names.hasMoreElements()) {

str = (String) names.nextElement(); System.out.println(str + ": " + balance.get(str)); }

 

Properties 接口：继承于 Hashtable.表示一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。

                                Properties()      Properties(Properties propDefault)

除了从Hashtable中所定义的方法，Properties定义了以下方法：

String getProperty(String key)用指定的键在此属性列表中搜索属性。

String getProperty(String key, String defaultProperty)用指定的键在属性列表中搜索属性。

void list(PrintStream streamOut)将属性列表输出到指定的输出流。

void list(PrintWriter streamOut)将属性列表输出到指定的输出流。

void load(InputStream streamIn) throws IOException从输入流中读取属性列表（键和元素对）。

Enumeration propertyNames( )按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

Object setProperty(String key, String value)调用 Hashtable 的方法 put。

void store(OutputStream streamOut, String description)以适合使用  load(InputStream)方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。

遍历：

Properties capitals = new Properties();

Set states;

String str;

capitals.put("Illinois", "Springfield"); 

states = capitals.keySet(); 

Iterator itr = states.iterator();

while(itr.hasNext()) { str = (String) itr.next(); System.out.println("The capital of " + str + " is " + capitals.getProperty(str) + "."); }

 

Date类：Date date = new Date();

 

boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。

boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。

Object clone( ) 返回此对象的副本。

int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。

int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。

boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。

long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

int hashCode( )  返回此对象的哈希码值。

void setTime(long time)   用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。

String toString( ) 转换Date对象为String表示形式，并返回该字符串。

使用SimpleDateFormat格式化日期：

Date dNow = new Date( );

SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

System.out.println("Current Date: " + ft.format(dNow));

使用printf格式化日期：

Date date = new Date();

// 使用toString()显示日期和时间

String str = String.format("Current Date/Time : %tc", date ); //以t开头c F D T r......

System.out.printf(str);

解析字符串为时间:

SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");

String input = args.length == 0 ? "1818-11-11" : args[0];

Date t;

try { t = ft.parse(input); System.out.println(t); }

catch (ParseException e) { System.out.println("Unparseable using " + ft); }

休眠：Thread.sleep(5*60*10);

测量时间：long start = System.currentTimeMillis( );

                  long end = System.currentTimeMillis( );

                  long diff = end - start;

Calender 类:

Calendar c = Calendar.getInstance();

或者

Calendar c1 = Calendar.getInstance();

c1.set(2009, 6 - 1, 12);//public final void set(int year,int month,int date)

c1.add(Calendar.DATE, 10);

 

随机Tip:

• 结束程序：System.exit(0)
• 可以从命令行向main方法传递参数,存储在args[]中
• 不再需要某个对象时给其引用变量赋null值，Java虚拟机会自动回收其所占空间；
• 类型转换：

                        返回基本数据类型——Integer.parseInt(String str) 是指把字符串转换为数值型        

                        返回包装类 —— Integer.valueOf(String str).intValue()  

                        把一个引用类型转化为String字符串类型——Integer.toString(int i)

                        SimpleDateFormat sf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

• 符号*用于命令行时加""，否则表示当前目录下的所有文件
• 限定字符串对象------String对象不可变,如果两个直接量字符串有相同字符序列,Java虚拟机将其存储在一个对象中
• StringBuilder/StringBuffer对象可添加插入或追加新的内容
• float/0-----输出Infinity