android开发学习-3

Implements。实例化接口；

Interface role{

Int fire;

}

Class magicstick implements weapom{

Public int fire{

Return 0;

}

}

 

字母拼接：直接使用stringbuffer （）；

线程安全：同时只能被一个线程修改。不能同时多个修改；

没有“+”直接连接这回事；更安全。

对比

String。则没有这些特性、字符可以直接用“+”来进行连接

eclipse：

Ctrl+左键。打开jdk中的源码。就可以找到很多的东西。（按住ctrl后鼠标点击string）；

Ctrl+f；寻找要找的方法：

 

 

正则表达是：给定的格式是不是制定的特定格式。灵活性。逻辑性。功能性很强

 加减乘除都要用转义字符进行转义：。转义字符 \\ 斜杠

Main（）{

     String s=”sscffs+sda-sad”;

     Patten p=pattern.compile(“fs\\+”);

     Matcher m=p.matcher(s);

     Pring(m.group());

//找到匹配fs+字符；有返回ture；

While（m.find()）

{

       Print(m.group);//用while循环输出多个匹配

}

 

System.out.println(pattern.matches(\\+fsf\\+,s));

//判断s中是否有+fsf+如果有返回ture.

a.CharAt（）获取字符；

}

a. matches()特定字符对比。

while (true){

String str=sc.nextLine();

//if(str.matches("\\w{6，}"))//输入长大于6的字符。{6}特定长度为6的。{6,8}长度为6到8位这么长；[]特定字

\\w:输入任意字符；

 

if(str.matches("\\w+@\\w+\\.(cn|com|net)+")){

//str.matches("^[0-9]+[a-zA-z][o-9a-zA-z]{4,}");

System.out.println("输入正确");

break;

}

System.out.println("用户名不正确");

b.  }

String str=sc.nextline();//表示输入的是字符窜。

List list=new arraylist();//  定义一个list

List.add(“”);

List.(2,””)

List.get(3);只有一个参数。即第几个数：从0开始。

 

当list赋给abc的对象。更改abc的属性。则list中也会跟这更改。因为应用的是同一块内存。

For循环。下标比增强for循环还快。

 

 

集合即容器；

package com.nteach;

 

public class Name {

private String Firstname,Lastname;

 

public Name(String firstname, String lastname) {

super();

this.Firstname = firstname;

this.Lastname = lastname;

}

 

public String getFirstname() {

return Firstname;

}

 

public void setFirstname(String firstname) {

Firstname = firstname;

}

 

public String getLastname() {

return Lastname;

}

 

public void setLastname(String lastname) {

Lastname = lastname;

}

 

@Override

public String toString() {

return "Name [Firstname=" + Firstname + ", Lastname=" + Lastname + "]";

}

}

 

 

package com.nteach;

 

import java.util.Collection;

import java.util.HashSet;

import java.util.Iterator;

 

public class text {

 

public static void main(String[] args) {

Collection c=new HashSet();

c.add(new Name("f1","l1"));

c.add(new Name("f2","l2"));

Iterator i=c.iterator();

while(i.hasNext()){

Name n=(Name)i.next();

System.out.println(n.FirstName);

}

}

}

 

构造方法即给类最新执行的方法；

Interface:

Collection有两个子接口:set ;list;

Map不是collection的子接口;

Set中的数据对象没有顺序并且不可重复(值);

List的数据有顺序可以重复;

 

Map:定义了存储的key-value;

Iterator Iterator();迭代;

Object[] toarray();返回转换成数组;

Import 导入包关键字。Java.util.*；

Remove在移除的时候是先通过比较两个对象的hashcode和equals

Hashcode是将属性转换成哈希码。然后再对比。先做hashcode。总和通常相同的很少。为什么现在。因为速度比较快。

Equals是第二次比较。

 

 

网上找到：Java中的Hashtables

Java包含两个类，java.util.Hashtable 和java.util.HashMap，它们提供了一个多种用途的hashtable机制。这两个类很相似，通常提供相同的公有接口。但它们的确有一些重要的不同点，我在后面会讲到。 

 

Hashtable和HashMap对象可以让你把一个key和一个value结合起来，并用put() 方法把这对key/value输入到表中。然后你可以通过调用get()方法，把key作为参数来得到这个value（值）。只要满足两个基本的要求， key和value可以是任何对象。注意，因为key和value必须是对象，所以原始类型（primitive types）必须通过运用诸如Integer(int)的方法转换成对象。

 

为了将一个特定类的对象用做一个key，这个类必须提供两个方法，equals() 和 hashCode()。这两个方法在java.lang.Object中，所以所有的类都可以继承这两个方法；但是，这两个方法在Object类中的实现一般没什么用，所以你通常需要自己重载这两个方法。

 

Equals ()方法把它的对象同另一个对象进行比较，如果这两个对象代表相同的信息，则返回true。该方法也查看并确保这两个对象属于相同的类。如果两个参照对象 是完全一样的对象，Object.equals()返回true，这就说明了为什么这个方法通常不是很适合的原因。在大多数情况下，你需要一个方法来一个 字段一个字段地进行比较，所以我们认为代表相同数据的不同对象是相等的。 

 

HashCode()方法通过运用对象的内容执行一个哈希函数来生成一个int值。Hashtable和HashMap用这个值来算出一对key/value位于哪个bucket（哈希元）（或列表）中。

 

作为例子，我们可以查看一下String 类，因为它有自己的方法来实现这两个方法。String.equals()对两个String对象一个字符一个字符地进行比较，如果字符串是相同的，则返回true：

String myName = "Einstein";

// The following test is 

// always true

if ( myName.equals("Einstein") )

{ ...

 

String.hashCode ()在一个字符串上运行哈希函数。字符串中每个字符的数字代码都乘以31，结果取决于字符串中字符的位置。然后将这些计算的结果相加，得到一个总数。这个 过程似乎很复杂，但是它确保能够更好地分布值。它也证明了你在开发你自己的hashCode()方法时，能够走多远，确信结果是唯一的。

 

例如，假设我要用一个hashtable来实现一个书的目录，把书的ISBN号码作为搜索键来进行搜索。我可以用String类来承载细节，并准备好了equals()和hashCode()方法（见列表1）。我们可以用put()方法添加成对的key/value到hashtable中（见列表2）。

 

Put()方法接受两个参数，它们都属于Object类型。第一个参数是key；第二个参数是value。Put()方法调用key的hashCode()方法，用表中的列表数来除这个结果。把余数作为索引值来确定该条记录添加到哪个列表中。注意，key在表中是唯一的；如果你用一个已经存在的key来调用put()，匹配的条目就被修改了，因此它参照的是一个新的值，而旧的值被返回了（当key在表中不存在时，put()返回空值）。

 

要读取表中的一个值，我们把搜索键用于get()方法。它返回一个转换到正确类型的Object参照：BookRecord br =

(BookRecord)isbnTable.get(

"0-345-40946-9");

System.out.println(

"Author: " + br.author+ " Title: " + br.title);

 

另一个有用的方法是remove()，其用法同get()几乎一样，它把条目从表中删除，并返回给调用程序。

 

你自己的类

如果你想把一个原始类型用做一个key，你必须创建一个同等类型的对象。例如，如果你想用一个整数key，你应该用构造器 Integer(int)从整数中生成一个对象。所有的封装类??如Integer、Float和Boolean都把原始值看做是对象，它们重载了 equals()和hashCode() 方法，因此，它们可以被用做key。JDK中提供的许多其它的类也是这样的（甚至Hashtable和HashMap类都实现它们自己的equals() 和hashCode()方法），但你把任何类的对象用做hashtable keys前，应该查看文件。查看类的来源，看看equals()和hashCode()是如何实现的，也很有必要。例如，Byte、Character、 Short和Integer都返回所代表的整数值作为哈希码。这可能适合，也可能不适合你的需求。

 

在Java中运用Hashtables

 

如果你想创建一个hashtable，这个hashtable运用你自己定义的一个类的对象作为key，那么你应该确信这个类的equals()和hashCode()方法提供有用的值。首先查看你扩展的类，确定它的实现是否满足你的需求。如果没有，你应该重载方法。

 

任何equals()方法的基本设计约束是，如果传递给它的对象属于同一个类，而且它的数据字段设定为表示同样数据的值，那么它就应该返回 true。你也应该确信，如果传递一个空的参数给该方法，那么你的代码返回false：public boolean equals(Object o)

{

if ( (o == null)

|| !(o instanceof myClass))

{

return false;

}

 

// Now compare data fields...

 

另外，在设计一个hashCode()方法时，应该记住一些规则。首先，该方法必须为一个特定的对象返回相同的值，而不管这个方法被调用了多少次 （当然，只要对象的内容在调用之间没有改变，在将一个对象用做一个hashtable的key时，应该避免这一点）。第二，如果由你的equals()方 法定义的两个对象是相等的，那么它们也必须生成相同的哈希码。第三，这更像是一个方针，而不是一个原则，你应该设法设计方法，使它为不同的对象内容生成不 同的结果。如果偶尔不同的对象正好生成了相同的哈希码，这也不要紧。但是，如果该方法只能返回范围在1到10的值，那么只能用10个列表，而不管在 hashtable中有多少个列表。

 

在设计equals()和hashCode（）时，另一个要记住的因素是性能问题。每次调用put() 或get()，都包括调用hashCode()来查找正确的列表，当get()扫描列表来查找key时，它为列表中的每个元素调用equals()。实现 这些方法使它们尽可能快而有效地运行，尤其当你打算使你的类公开可用时，因为其它的用户可能想在执行速度很重要的情况下，在高性能的应用程序中运用你的 类。

 

Hashtable性能

影响hashtable功效的主要因素就是表中列表的平均长度，因为平均搜索时间与这个平均长度直接相关。很显然， 要减小平均长度，你必须增加hashtable中列表的数量；如果列表数量非常大，以至于大多数列表或所有列表只包含一条记录，你就会获得最佳的搜索效 率。然而，这样做可能太过分了。如果你的hashtable的列表数远远多于数据条目，那你就没有必要做这样的内存花费了，而在一些情况下，人们也不可能 接受这样的做法。

在我们前面的例子中，我们预先知道我们有多少条记录1,000。知道这点后，我们就可以决定我们的hashtable 应该包含多少个列表，以便达成搜索速度和内存使用效率之间最好的折中方式。然而，在许多情况下，你预先不知道你要处理多少条记录；数据被读取的文件可能会 不断扩大，或者记录的数量可能一天一天地发生很大的变化。

 

随着条目的增加，Hashtable和HashMap类通过动态地扩展表来处理这个问题。这两个类都有接受表中列表最初数量的构造器，和一个作为参数的负载系数（load factor）：public Hashtable(

int initialCapacity,

float loadFactor)

 

public HashMap(

int initialCapacity,

float loadFactor)

 

将这两个数相乘计算出一个临界值。每次给哈希表添加一个新的条目时，计数就被更新，当计数超过临界值时，表被重新设置（rehash)。（列表数量 增加到以前数量的两倍加1，所有的条目转移到正确的列表中。）缺省的构造器设定最初的容量为11，负载系数是0.75，所以临界值是8。当第九条记录被添 加到表中时，就重新调整哈希表，使其有23个列表，新的临界值将是17（23*0.75的整数部分）。你可以看到，负载系数是哈希表中平均列表数量的上 限，这就意味着，在缺省情况下，哈希表很少会有许多包含不只一条记录的列表。比较我们最初的例子，在那个例子中，我们有1,000条记录，分布在10个列 表中。如果我们用缺省值，这个表将会扩展到含有1,500多个列表。但你可以控制这点。如果用负载系数相乘的列表数量大于你处理的条目数，那么表永远不会 重制，所以我们可以仿效下面的例子：// Table will not rehash until it

// has 1,100 entries (10*110):

Hashtable myHashTable = 

new Hashtable(10, 110.0F);

 

你可能不想这么做，除非你没有为空的列表节省内存，而且不介意额外的搜索时间，这可能在嵌入系统中会出现这种情况。然而，这种方法可能很有用，因为重新设置很占用计算时间，而这种方法可以保证永远不会发生重新设置这种情况。

 

注意，虽然调用put()可以使表增大（列表数量增加），调用remove()不会有相反的结果。所以，如果你有一个大的表，而且从中删除了大部分条目，结果你会有一个大的但是大部分是空的表。

Hashtable和HashMap

Hashtable和HashMap类有三个重要的不同之处。第一个不同主要是历史原因。Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

 

也许最重要的不同是Hashtable的方法是同步的，而HashMap的方法不是。这就意味着，虽然你可以不用采取任何特殊的行为就可以在一个多 线程的应用程序中用一个Hashtable，但你必须同样地为一个HashMap提供外同步。一个方便的方法就是利用Collections类的静态的 synchronizedMap()方法，它创建一个线程安全的Map对象，并把它作为一个封装的对象来返回。这个对象的方法可以让你同步访问潜在的HashMap。这么做的结果就是当你不需要同步时，你不能切断Hashtable中的同步（比如在一个单线程的应用程序中），而且同步增加了很多处理费用。

 

第三点不同是，只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key，但任 意数量的条目可以是空的value。这就是说，如果在表中没有发现搜索键，或者如果发现了搜索键，但它是一个空的值，那么get()将返回null。如果 有必要，用containKey()方法来区别这两种情况。

 

一些资料建议，当需要同步时，用Hashtable，反之用HashMap。但是，因为在需要时，HashMap可以被同步，HashMap的功能 比Hashtable的功能更多，而且它不是基于一个陈旧的类的，所以有人认为，在各种情况下，HashMap都优先于Hashtable。

 

关于Properties

有时侯，你可能想用一个hashtable来映射key 的字符串到value的字符串。DOS、Windows和Unix中的环境字符串就有一些例子，如key的字符串PATH被映射到value的字符串C: \WINDOWS;C:\WINDOWS\SYSTEM。Hashtables是表示这些的一个简单的方法，但Java提供了另外一种方法。

 

Java.util.Properties类是Hashtable的一个子类，设计用于String keys和values。Properties对象的用法同Hashtable的用法相象，但是类增加了两个节省时间的方法，你应该知道。

 

Store()方法把一个Properties对象的内容以一种可读的形式保存到一个文件中。Load()方法正好相反，用来读取文件，并设定Properties对象来包含keys和values。

 

注意，因为Properties扩展了Hashtable，你可以用超类的put()方法来添加不是String对象的keys和values。这是不可取的。另外，如果你将store()用于一个不包含String对象的Properties对象，store()将失败。作为put()和get()的替代，你应该用setProperty()和getProperty()，它们用String参数。

 

好了，我希望你现在可以知道如何用hashtables来加速你的处理了

 

 

Iterator：迭代器、遍历元素的。主要有3种方法。

Boolean hasNext（）；//游标右边是否有元素；

Object  next()；返回游标右边的元素并将游标移动到下一个位置；

Void remove（）；删除游标走边的元素，在执行完next之后该操作只能执行一次

Collection c=new hashSet();

Iterator it=c.iterator();找到hashset然后把游标放到第一个元素前；

^Println(it.next()); 输出的是hashset中的第一个元素；输出的是没有顺序的。因为是hashset. 所以没有顺序。是随意输出的。

 

For(int I:a){//从数组中抽出一个数赋值给i；一个一个的取出来赋值；从第一个到最好一个这就是增强for循环

^print(i);}

Collection c=new arrayList();//要导入两个包。这句import java。Util.*；就等于把Util包中的类全部倒入

 

package com.nteach;

import java.util.Collection;

import java.util.HashSet;

import java.util.Iterator;

public class text {

public static void main(String[] args) {

Collection<Name> c=new HashSet<Name>();

c.add(new Name("f1","l1"));

c.add(new Name("f2","l2"));

Iterator<Name> i=c.iterator();

while(i.hasNext()){

Name n=(Name)i.next();

System.out.println(n.Firstname);

}

for(Name i1:c){

System.out.println(i1.Firstname.toString());

}

}

}

package com.nteach;

public class Name {

String Firstname,Lastname;

public Name(String firstname, String lastname) {

super();

this.Firstname = firstname;

this.Lastname = lastname;

}

public String getFirstname() {

return Firstname;

}

public void setFirstname(String firstname) {

Firstname = firstname;

}

public String getLastname() {

return Lastname;

}

public void setLastname(String lastname) {

Lastname = lastname;

}

@Override

public String toString() {

return "Name [Firstname=" + Firstname + ", Lastname=" + Lastname + "]";

}

}

 

Sets1=new Hashset();

Sets2=new Hashset();

 

S1.add(“a”); S1.add(“b”); S1.add(“c”);

S2.add(“d”); S2.add(“a”); s3.add(“b”);

Set sn=new hashset(s1);直接在sn中方副本；

Sn.retainall(s2);取交集；

Set su=new hashset(s1);

Su.addall(s2);

^print(sn);//输出 a,b;

^print(su);//输出这几个数。也许顺序不同d,a,c,b;

 

List接口:

Object Get(int index)；//下标

Object set(int index,object element);//下标，element：若有值 返回；

Object add(int index,object element);//下标，值：会覆盖，没返回

Object remove(int index);

Int indexof(object o);

Int lastIndexOf(object o);返回最后一个；

 

Listl1=new linkedlist();

For(int i=0;i<=;I++){li.add(“a”+i);}

Print(l1);

L1.add(3,”100”);

Print(l1);

L1.set(6,”a200”);

Print(l1);

Print((string)l1.get(2)+” ”);输出下标为2的值

Print(l1.indexof(“a3”))；//输出a3的下标

li.remove(1)；//除去下标为1的值

 

 

java.util.collections

collections提供了一些静态方法实现了基于List容器的一些常用的算法；

void sort(list)对list容器内德元素排序

void shuffle(list)对list容器内的对象进行随机排序

void reverse(list) 对list容器内德对象进行逆序排列。就是把list整个数组逆向排序。A.1=a.last…   a.last=a.1

void fill(list,object)用一个特定的对象重写整个list容器

void copy(list dext,list src)将src list容器内容拷贝到dest List容器

Int binarysearch(list,key)折半查找、找出下标  必须先排列才能用。也就是先用 sort

 

自动封包

set s=new hashset();

s.add(new integer(100));

s.add(100);这就是自动封包。但是加不进去。因为是hashset；这句和上面一句相同。

 

 

//

For（int i=0；i<list.size();i++）{

String str=(string)list.get(i);

System.out.print(str);

}

//可以化简：就是把list.size()与string str.都写到for外头。这样就减少了内存开销；因为没次循环都要执行size。和弄个对象；

循环可以用toarray先转成数组。然后用下标遍历。