3024人阅读
在Windows平台进行网络程序开发, 可以使用不同的库, 但是最常用的还是微软自己开发的库。具体说来，有：
（1）Winsock，工作于网络层和传输层的开发库，对于编写TCP，UDP，以及原始IP通信程序非常合适。函数原形也基本符合Unix socket标准。Windows平台上的大多数程序，如QQ，讯雷等都基于其开发。
（2）ws2_32，是Winsock的升级版本，在兼容的基础上增加了不符合Unix socket标准，但更适合Windows平台的库函数，一般以WSA*开头。
现代的大多数Windows平台程序也都开始依赖于此库。
（3）WinInet，Windows Internet扩展库，工作于应用协议层，提供了http，ftp，gopher协议的实现，为基于以上三种协议的程序开发提供基础平台，需要说明的是，尽管WinInet工作于应用层，但其本身wininet.dll的实现并不依赖于winsock.dll或ws2_32.dll,而是独立存在的。至少目前的版本是这样。基于WinInet的应用程序最著名的例子就是IE了。
（4）WinHttp，也是工作于应用协议层，提供了http协议的实现。看起来与WinInet有重复的部分，没错，WinHttp就是为了替换WinInet中的http部分的，它更加健壮稳定，而且还为http服务器端开发提供了库函数。如果进行现代http的开发，建议使用WinHTTP而不是WinInet。使用WinHTTP进行开发的著名例子就是Google的浏览器Chrome，但是Chrome2.0以后版本google放弃了winhttp而是使用了自己开发的http库，这也是为了使chrome实现跨平台的重要举措。另外，WinHttp.dll也不依赖于winsock或ws2_32，也是独立运行的。
如果基于socket编程的话，Winows平台与其它平台函数基本相同，实现跨平台比较容易。
如果基于http进行编程的话，不同平台库差别很大，如果不考虑跨平台使用WinHttp，如果考虑跨平台可以考虑使用libwww。
另外,wsock和wininet或winhttp也可以同时使用。
WinInet HttpSendRequest使用的事项
HttpSendRequest不支持异步模式，虽然API文档说可以，但是在其它官方文章中已证实不可以；要用异步方式完成任务，需要通过使用线程来自己封装。HttpSendRequest使用的INTERNETHANLE要每次通过HttpOpenRequest获取，不能重用，否则可能会出现无法读取返回数据或数据重复等错误；虽然API文档说只要每次把上次的数据取完就可以，但这是经历了无数痛苦的unit test后换来的经验。发送httpSendRequest后，需要使用InternetReadFile来读取，重复多次读，直到返回数据为0byte为止。错误代码在& ，API文档中找不到。
什么是WinHTTP?
WinHTTP的全称是Microsoft Windows HTTP Services, 它提供给开发者一个HTTP客户端应用程序接口(API), 通过这种API借助HTTP协议给其他的HTTP服务器发送请求.
WinHTTP支持桌面应用程序, Windows系统服务, 和Windows服务器端应用程序.
对于基于Microsoft .NET Framework的应用程序, 不推荐使用WinHTTP服务, 因为.NET Framework应用程序应该使用在System.Net命名空间下的网络基础设施类型.
WinHTTP提供了两种编程方式, 一种是CC++的API, 另一种是COM组件.
WinHTTP与WinINet的区别
================
WinHTTP被设计为主要应用在服务器端应用程序的场景下, 让服务器端应用程序访问HTTP服务器.
WinINet是一种更老的技术, 它被设计为一个HTTP客户端平台, 用于交互式桌面应用程序, 比如说IE, Office等.
服务器端应用程序要求HTTP客户端服务使用WinHTTP而不是WinINet.
WinHTTP和WinINet在微软是由不同的团队来提供支持的.
WinHTTP与Proxy
================
如果HTTP Proxy需要认证(authentication), 那么HTTP Application会收到407(proxy requires authentication). 除了这个状态码, 代理服务器还会发送一个或更多的authenticate headers: “Proxy-Authenticate”. 这些信息足够我们在network monitor trace中鉴定HTTP无法访问是否是由于proxy需要认证引起的了.
WinHTTP的proxy配置是存储在注册表键
HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionInternet SettingsConnectionsWinHttpSettings
当中的, 修改和查看需要使用一个命令行工具proxycfg.
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：153054次
积分：1906
积分：1906
排名：第10936名
原创：35篇
转载：24篇
评论：31条
(1)(5)(6)(4)(3)(7)(1)(2)(7)(4)(3)(11)(4)(1)下次自动登录
现在的位置:
& 综合 & 正文
【转】清理浮动的全家
原文地址：
早段时间特别的忙，忙到站点一直没有更新；但是这段时间也是偷偷的做了一些的工作，比如对站点的JS进行了压缩，构思labs分站以及聚合分站。
而此段时间最烦的是森林群里面的一群人每天上班都在吵，然后我就每次都装嫩的在里面问：“各位高手，劳烦请问一下；清除浮动怎么弄？”
清除浮动一个凡是做页面的人都会遇到的一个东西，但是是否大家都能够清楚的知道，全方位的了解呢？于是一闲下来了马上写了这样的一篇，不能讲面面俱到，然而基本能将我所知道的倾囊相授了。
我们粗略的一起来看看清除浮动的办法一共有多少个(IE里面用zoom:1就不写了，下一个专题再写)。对应的
采用伪类:after进行后续空制的高度位零的伪类层清除
采用CSS overflow:auto的方式撑高
采用CSS overflow:hidden的方式产生怪异适应
采用display:table将对象变成table形式
采用div标签，以及css的clear属性
采用br标签，以及css的clear属性
采用br标签，以及其自身HTML的clear属性
粗略的看，他们都能将问题解决；然而他们另外一方面又有着各自的利弊。（一一对应）
优点结构语义化完全正确，不会产生其余的怪异问题。
缺点复用方式不当容易造成量急剧增大。
建议最外层轻浮动时使用，或清晰模块化复用方式的人使用。
优点结构语义化完全正确，代码量极少。
缺点多个嵌套后，点击最外层的轻浮动框会遭成最外层至最内层内容全选（FF）；或者在mouseover造成宽度改变时会出现最外层模块有滚动条（IE）。
建议内个模块使用，请勿嵌套。
优点结构语义化完全正确，代码量极少。
缺点内容增多时候极易不会自动换行而内容被隐藏掉。
建议宽度固定时使用，请勿嵌套。
优点结构语义化完全正确，代码量极少。
缺点盒模型属性已经改变，可想而知奇异事件自然多得你数都数不到。
建议如果你不想改Bug改死你的话，最好不要使用；不过可以作为alpha版本当中临时性的忽悠下测试。
优点代码量极少，复用性极高。
缺点完全不能完美的适应语义化，不利于改版以及需求变更。
建议初学者使用，可以让你快速的解决浮动问题。
优点语义化程度比第5种情况要更优；代码量极少，复用性极高。
缺点语义化依旧不完美，不利于改版以及需求变更。
建议初学者使用，可以让你快速的解决浮动问题。
优点语义化程度比第5、6种情况要更优；代码量最少，复用性极高。
缺点语义化依旧不完美，不利于改版以及需求变更。
建议引导初学者思维升级时使用，让其明白与其用classname来控制一种表现，倒不如回归到WEB1.0的时代的网页直接用html属性来控制表现，毕竟后者的代码量更少。
&&&&推荐文章:
【上篇】【下篇】随笔 - 133&
文章 - 48&
trackbacks - 0
2627282930311234567891011121314151617181920212223242526272829303112345
NB的代码下载网站
教程很详细
可以使用赋值开发工具RenderMonkey
阅读排行榜
评论排行榜
&&&今天编译完CEGUI后运行时提示我缺少MSVCP80D.DLL，搜了下找到了解决方案 备忘.&& 在VS 2005中建立Win32工程时（以VS 2005中文版为例），你可能会遇到这样的运行错误：“没有找到MSVCP80D.dll，因此这个应用程序未能启动。重新安装应用程序可能会修复此问题。”（还可能是其它几个类似的文件：MSVCR80D.dll、MSVCM80D.dll）。对于VS2005新手，可能遇到的第一个问题便是此问题。一直使用VC6进行开发测试，最近准备把平台转移到VS2005（过些天就应该转VS2008了，呵呵）上来。于是，决定先把CppUnit转移到此平台上来。在VS2005中编译CppUnit所遇到的问题不多，虽然没VC6方便。但是在测试编译好的CppUnit库时却遇到了困难：把以前在VC6中写的AES移植过来（其使用了CppUnit进行单元测试），在运行时却遇到了如上错误。刚开始以为可能是CppUnit没有编译好，重新编译CppUnit多次，调整编译参数，但始终有此错误，并且此错误有时出现有时不出现，这更晕了，大量时间就这样浪费了。等我静下来，才觉得可能是VS 2005的原因，于是上网搜索此错误信息，终于找到了问题所在。
VS 2005在生成可执行文件时使用了一种新的技术，该技术生成的可执行文件会伴随生成一个清单文件（manifest file）（.manifest后缀文件）（其本质上是XML文档，你可以用文本编辑器打开看看），并在链接完成后将该清单文件嵌入到exe文件中（默认情况下）。而在FAT32文件系统中，在处理清单文件阶段，当增量链接时不能完成清单文件的更新（默认情况下），于是造成清单文件嵌入失败，从而使该exe文件运行时没有相应的清单文件而运行失败并提示如上错误。
解决方案很多，列举如下：1. 由于这是在链接动态运行库出现的问题，所以你可以选择代码生成的连接方式为/MTd而非/MDd，不用这些DLL文件从而避免问题的出现。该方法有一个很显然的缺点：适用范围有限，并且也不是我等提倡的解决问题的方式，不推荐该方法。
2. 既然跟FAT32系统有关，那么我们可以选择在NTFS文件系统中开发从而避免该问题，此方法同上，也是采用的回避问题的方式，不为我等提倡。
3. 该方法仍与FAT32有关：在项目的“属性｜配置属性｜清单工具｜常规”中的“使用FAT32解决办法”选择“是”（默认为“否”），重新生成项目即可解决问题。该方法是唯一真正针对问题所在而提出的解决方法，使清单工具可以正确更新。（此方法是官方解决方法，也比较方便，推荐）
4. 既然问题是在更新嵌入的清单文件时发生的，由于FAT32的原因而未能更新嵌入的清单文件，于是我们有如下两种解决方法：（1）不启用增量链接。在项目的“属性｜配置属性｜链接器｜常规”中的“启用增量链接”选择“否”。此方法阻断了问题产生的源头，其每次生成exe文件时都直接嵌入清单文件，而不是默认的根据时戳而决定是否更新清单文件。（2）不嵌入清单文件。在项目的“属性｜配置属性｜清单工具｜输入和输出”中的“嵌入清单”选择“否”，从而在生成exe文件时附随生成一个清单文件（默认情况下，其文件名为exe文件的全名加上“.manifest”），避免了嵌入清单文件可能失败的问题。在程序运行时，会用到该清单文件。显然，这种方式使可执行程序产生了更多的外部依赖，不推荐。
另外，还有一个不能称为方法的土办法：每次Build前手动删除*.ilk文件（增量链接文件）（当然可以在项目属性中写入删除命令，使其自动执行），不推荐该土办法。
最后，总结一下：1. 此问题只在特定条件下才会出现：在FAT32文件系统中编译、默认设置（增量模式、不启用FAT32解决方案、嵌入清单文件）、非第一次生成可执行文件文件（即在增量连接、更新清单文件时）。2. 解决方案1和4.1方便实用，推荐使用。黑马程序员 集合框架
编辑：www.fx114.net
本篇文章主要介绍了"黑马程序员 集合框架"，主要涉及到黑马程序员 集合框架方面的内容，对于黑马程序员 集合框架感兴趣的同学可以参考一下。

&&& &--------------、、学习型技术博客、期待与您交流！
--------------
集合框架：用于存储数据的容器。
1：对象封装数据，对象多了也需要存储。集合用于存储对象。
2：对象的个数确定可以使用数组，但是不确定怎么办？可以用集合。因为集合是可变长度的。
集合和数组的区别：
1：数组是固定长度的；集合可变长度的。
2：数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。
3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。
数据结构：就是容器中存储数据的方式。
对于集合容器，有很多种。因为每一个容器的自身特点不同，其实原理在于每个容器的内部数据结构不同。
集合容器在不断向上抽取过程中。出现了集合体系。
在使用一个体系时，原则：参阅顶层内容。建立底层对象。
--& java.util&--Collection接口：
Collection：
&&&|--List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。
&&&|--Set：无序(存入和取出顺序有可能不一致)，不可以存储重复元素。必须保证元素唯一性。
&&&add(object)：添加一个元素
&&&addAll(Collection)
：添加一个集合中的所有元素。
&&&clear()：将集合中的元素全删除，清空集合。
&&&remove(obj)
：删除集合中指定的对象。注意：删除成功，集合的长度会改变。
&&&removeAll(collection)
：删除部分元素。部分元素和传入Collection一致。
&&&boolean contains(obj)
：集合中是否包含指定元素 。
&&&booleancontainsAll(Collection)
：集合中是否包含指定的多个元素。
&&&boolean isEmpty()：集合中是否有元素。
&&&int size()：集合中有几个元素。
5，取交集：
&&&boolean&
retainAll(Collection) ：对当前集合中保留和指定集合中的相同的元素。如果两个集合元素相同，返回flase；如果retainAll修改了当前集合，返回true。
6，获取集合中所有元素：
&&&Iterator&iterator()：迭代器
7，将集合变成数组：
&&&toArray();
------------------------------------------------------------
--& java.util&--Iterator接口：
迭代器：是一个接口。作用：用于取集合中的元素。
()如果仍有元素可以迭代，则返回true。
()返回迭代的下一个元素。
()从迭代器指向的中移除迭代器返回的最后一个元素（可选操作）。
每一个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素。将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator接口。
也就说，只要通过该接口就可以取出Collection集合中的元素，至于每一个具体的容器依据自己的数据结构，如何实现的具体取出细节，这个不用关心，这样就降低了取出元素和具体集合的耦合性。
Iterator it = coll.iterator();//获取容器中的迭代器对象，至于这个对象是是什么不重要。这对象肯定符合一个规则Iterator接口。
-----------------------------------------------------------------------------
public static voidmain(String[] args) {
&&&&&&&Collection coll =new ArrayList();
&&&&&&&coll.add(&abc0&);
&&&&&&&coll.add(&abc1&);
&&&&&&&coll.add(&abc2&);
&&&&&&&//--------------方式1----------------------
&&&&&&&Iterator it =coll.iterator();
&&&&&&&while(it.hasNext()){
&&&&&&&&&&&System.out.println(it.next());
&&&&&&&//---------------方式2用此种----------------------
&&&&&&&for(Iterator it = coll.iterator();it.hasNext(); ){
&&&&&&&&&&&System.out.println(it.next());
-----------------------------------------------------------------------------
--& java.util&--List接口：
List本身是Collection接口的子接口，具备了Collection的所有方法。现在学习List体系特有的共性方法，查阅方法发现List的特有方法都有索引，这是该集合最大的特点。
List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。
&&&|--ArrayList：底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快。
&&&|--LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。
&&&|--Vector：底层的数据结构就是数组，线程同步的，Vector无论查询和增删都巨慢。
&&&add(index,element)
：在指定的索引位插入元素。
&&&addAll(index,collection)：在指定的索引位插入一堆元素。
&&&remove(index)
：删除指定索引位的元素。 返回被删的元素。
&&&Object get(index)
：通过索引获取指定元素。
indexOf(obj) ：获取指定元素第一次出现的索引位，如果该元素不存在返回-1；
&&&&&&&&&&&&&&&&&&&&
所以，通过-1，可以判断一个元素是否存在。
&&&int lastIndexOf(Objecto)
：反向索引指定元素的位置。
subList(start,end) ：获取子列表。
&&&Objectset(index,element)
：对指定索引位进行元素的修改。
5，获取所有元素：
&&&ListIterator
listIterator()：list集合特有的迭代器。
List集合支持对元素的增、删、改、查。
List集合因为角标有了自己的获取元素的方式： 遍历。
for(intx=0; x&list.size(); x++){
&sop(&get:&+list.get(x));
在进行list列表元素迭代的时候，如果想要在迭代过程中，想要对元素进行操作的时候，比如满足条件添加新元素。会发生.ConcurrentModificationException并发修改异常。
导致的原因是：
集合引用和迭代器引用在同时操作元素，通过集合获取到对应的迭代器后，在迭代中，进行集合引用的元素添加，迭代器并不知道，所以会出现异常情况。
如何解决呢？
既然是在迭代中对元素进行操作,找迭代器的方法最为合适.可是Iterator中只有hasNext,next,remove方法.通过查阅的它的子接口,ListIterator,发现该列表迭代器接口具备了对元素的增、删、改、查的动作。
ListIterator是List集合特有的迭代器。
ListIterator it =list.listI//取代Iterator it = list.
(&e)将指定的元素插入列表（可选操作）。
()以正向遍历列表时，如果列表迭代器有多个元素，则返回true（换句话说，如果next返回一个元素而不是抛出异常，则返回true）。
()如果以逆向遍历列表，列表迭代器有多个元素，则返回true。
()返回列表中的下一个元素。
()返回对next的后续调用所返回元素的索引。
()返回列表中的前一个元素。
()返回对previous的后续调用所返回元素的索引。
()从列表中移除由next或previous返回的最后一个元素（可选操作）。
(&e)用指定元素替换next或previous返回的最后一个元素（可选操作）。
可变长度数组的原理：
当元素超出数组长度，会产生一个新数组，将原数组的数据复制到新数组中，再将新的元素添加到新数组中。
ArrayList：是按照原数组的50%延长。构造一个初始容量为的空列表。
Vector：是按照原数组的100%延长。
注意：对于list集合，底层判断元素是否相同，其实用的是元素自身的equals方法完成的。所以建议元素都要复写equals方法，建立元素对象自己的比较相同的条件依据。
LinkedList：的特有方法。
addFirst();
addLast();
在jdk1.6以后。
offerFirst();
offerLast();
getFirst():获取链表中的第一个元素。如果链表为空，抛出NoSuchElementE
getLast();
在jdk1.6以后。
peekFirst();获取链表中的第一个元素。如果链表为空，返回null。
peekLast();
removeFirst()：获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，抛出NoSuchElementException
removeLast();
在jdk1.6以后。
pollFirst();获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，返回null。
pollLast();
------------------------------------------------------------
--& java.util&--Set接口：
Set接口中的方法和Collection中方法一致的。Set接口取出方式只有一种，迭代器。
&|--HashSet：底层数据结构是哈希表，线程是不同步的。无序，高效；
&&&&&HashSet集合保证元素唯一性：通过元素的hashCode方法，和equals方法完成的。
&&&&&当元素的hashCode值相同时，才继续判断元素的equals是否为true。
&&&&&如果为true，那么视为相同元素，不存。如果为false，那么存储。
&&&&&如果hashCode值不同，那么不判断equals，从而提高对象比较的速度。
&&&&&|--LinkedHashSet：有序，hashset的子类。
&|--TreeSet：对Set集合中的元素的进行指定顺序的排序。不同步。TreeSet底层的数据结构就是二叉树。
哈希表的原理：
1，对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法值，这个值
称为哈希值。
2，哈希值就是这个元素的位置。
3，如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。如果对象相同，就不存储，因为元素重复。如果对象不同，就存储，在原来对象的哈希值基础+1顺延。
4，存储哈希值的结构，我们称为哈希表。
5，既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。
&这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。
对于ArrayList集合，判断元素是否存在，或者删元素底层依据都是equals方法。
对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。
&用于对Set集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。
&如果元素不具备比较性，在运行时会发生ClassCastException异常。
&所以需要元素实现Comparable接口，强制让元素具备比较性，复写compareTo方法。
&依据compareTo方法的返回值，确定元素在TreeSet数据结构中的位置。
&TreeSet方法保证元素唯一性的方式：就是参考比较方法的结果是否为0，如果return
0，视为两个对象重复，不存。
注意：在进行比较时，如果判断元素不唯一，比如，同姓名，同年龄，才视为同一个人。
&在判断时，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。
TreeSet集合排序有两种方式，Comparable和Comparator区别：
1：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法。
2：让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数。
第二种方式较为灵活。
------------------------------------------------------------
|--Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。
|--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.
|--TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。
Map集合存储和Collection有着很大不同：
Collection一次存一个元素；Map一次存一对元素。
Collection是单列集合；Map是双列集合。
Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。
特点：要保证map集合中键的唯一性。
&put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。
putAll(Map);
clear()：清空
remove(key)：删除指定键。
isEmpty()：
containsKey(key)：是否包含key
containsValue(value)：是否包含value
size()：返回长度
get(key)：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。
&Collection
values()：获取map集合中的所有的值。
5，想要获取map中的所有元素：
&原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。
★把map集合转成set的方法：
Set keySet();
Set entrySet();//取的是键和值的映射关系。
Entry就是Map接口中的内部接口；
为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。
---------------------------------------------------------
取出map集合中所有元素的方式一：keySet()方法。
可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。
&&&&&Set keySet = map.keySet();
&&&&&Iterator it = keySet.iterator();
&&&&while(it.hasNext()){
&&&&&&&&Object key = it.next();
&&&&&&&&Object value = map.get(key);
&&&&&&&&System.out.println(key+&:&+value);
--------------------------------------------------------
取出map集合中所有元素的方式二：entrySet()方法。
SetentrySet = map.entrySet();
&&&&&&&Iteratorit = entrySet.iterator();
&&&&&&&while(it.hasNext()){
&&&&&&&&&&&Map.Entry
&me = (Map.Entry)it.next();
&&&&&&&&&&&System.out.println(me.getKey()+&::::&+me.getValue());
--------------------------------------------------------
使用集合的技巧：
看到Array就是数组结构，有角标，查询速度很快。
看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast；removeFirst()；
removeLast()；getFirst()；getLast()；
看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。
看到tree就是二叉树，就要想到排序，就想要用到比较。
比较的两种方式：
一个是Comparable：覆盖compareTo方法；
一个是Comparator：覆盖compare方法。
LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。
集合什么时候用？
当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。
保证唯一，就用Set。不保证唯一，就用List。
------------------------------------------------------------------------------------------------
Collections：它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。
静态方法：
Collections.sort(list);//list集合进行元素的自然顺序排序。
Collections.sort(list,newComparatorByLen());//按指定的比较器方法排序。
classComparatorByLen implements Comparator&String&{
&public int compare(String s1,String s2){
&&&&&int temp = s1.length()-s2.length();
&&&&&return temp==pareTo(s2):
Collections.max(list);//返回list中字典顺序最大的元素。
int index =Collections.binarySearch(list,&zz&);//二分查找，返回角标。
Collections.reverseOrder();//逆向反转排序。
Collections.shuffle(list);//随机对list中的元素进行位置的置换。
将非同步集合转成同步集合的方法：Collections中的&XXXsynchronizedXXX(XXX);
ListsynchronizedList(list);
MapsynchronizedMap(map);
原理：定义一个类，将集合所有的方法加同一把锁后返回。
Collection和Collections的区别：
Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。
-------------------------------------------------------
用于操作数组对象的工具类，里面都是静态方法。
asList方法：将数组转换成list集合。
String[] arr ={&abc&,&kk&,&qq&};
List&String&list = Arrays.asList(arr);//将arr数组转成list集合。
将数组转换成集合，有什么好处呢？用aslist方法，将数组变成集合；
可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；
注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；
如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。
如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。
集合变数组：用的是Collection接口中的方法：toArray();
如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。
&&&如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。
&&&所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。
将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只要获取这些元素即可。
------------------------------------------------------------------------------------------------
Jdk5.0新特性：
Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。
--------------------------------------------------
增强for循环：foreach语句，foreach简化了迭代器。
格式：//增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器
for(元素类型 变量名 :Collection集合&
高级for循环和传统for循环的区别：
高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。
如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。
高级for循环可以遍历map集合吗？不可以。但是可以将map转成set后再使用foreach语句。
1)、作用：对存储对象的容器进行迭代： 数组&
collection&&map
2)、增强for循环迭代数组：
String[] arr = {&a&, &b&, &c&};//数组的静态定义方式，只试用于数组首次定义的时候
for(Strings : arr) {
&System.out.println(s);&
3)、单列集合 Collection：
Listlist = new ArrayList();
list.add(&aaa&);
//增强for循环,没有使用泛型的集合能不能使用增强for循环迭代？能
for(Object obj : list) {
&String s = (String)
&System.out.println(s);
4)、双列集合 Map：
Map map= new HashMap();
map.put(&a&,&aaa&);
//传统方式：必须掌握这种方式
Set entrys = map.entrySet(); // 1.获得所有的键值对Entry对象
iter =entrys.iterator();// 2.迭代出所有的entry
while(iter.hasNext()){
&Map.Entry entry = (Entry) iter.next();
&String key = (String) entry.getKey();
//分别获得key和value
&String value = (String) entry.getValue();
&System.out.println(key + &=& +value);
//增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。
for(Object obj : map.entrySet()) {
&Map.Entry entry = (Entry)
&// obj依次表示Entry
&System.out.println(entry.getKey() +&=& + entry.getValue());
5）、集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。
6)、增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值；
int[]arr = {1,2,3};
for(intnum : arr) {
&num = 0; //不能改变数组的值
System.out.println(arr[1]); //2
--------------------------------------------------
可变参数（...）：用到函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。
和以前接收数组不一样的是：
以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。所以简化了用户的书写，少了调用者定义数组的动作。
如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败。)。
如果要获取多个int数的和呢？可以使用将多个int数封装到数组中，直接对数组求和即可。
---------------------------------------------------
静态导入：导入了类中的所有静态成员，简化静态成员的书写。
//导入了类中的所有静态成员
---------------------------------------------------
枚举：关键字
问题：对象的某个属性的值不能是任意的，必须为固定的一组取值其中的某一个；
解决办法：
）、在方法中做判断，不符合格式要求就抛出异常；
）、直接限定用户的选择，通过自定义类模拟枚举的方式来限定用户的输入，写一个类，私有构造函数，对外提供个静态的常量表示类的实例；
、中新定义了枚举类型，专门用于解决此类问题；
、枚举就是一个特殊的类，可以定义属性、方法、构造函数、实现接口、继承类；
自动拆装箱：中数据类型分为两种：基本数据类型引用数据类型对象
在程序中所有的数据都需要当做对象来处理，针对种基本数据类型提供了包装类，如下：
以前基本数据类型和包装类之间需要互转：
基本引用Integer
x = new Integer(x);
引用基本int
num = x.intValue();
、经历了什么过程？装箱à拆箱à装箱；
、为了优化，虚拟机为包装类提供了缓冲池，池的大小一个字节的大小；
、池：为了优化字符串操作提供了一个缓冲池；
----------------------------------------------------------
泛型：jdk1.5版本以后出现的一个安全机制。表现格式：&&
1：将运行时期的问题ClassCastException问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。
2：避免了强制转换的麻烦。
只要带有&&的类或者接口，都属于带有类型参数的类或者接口，在使用这些类或者接口时，必须给&&中传递一个具体的引用数据类型。
泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。
为什么?因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。
在运行时，如何知道获取的元素类型而不用强转呢？
泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。
什么时候用泛型类呢？
当类中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。
----------------------------------------------------------
泛型在程序定义上的体现：
//泛型类：将泛型定义在类上。
class Tool&Q& {
&&&private Q
&&&public&
void setObject(Q obj) {
&&&&&&&this.obj =
&&&public Q getObject() {
//当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上。
&&&public &W& voidmethod(W w) {
&&&&&&&System.out.println(&method:&+w);
//静态方法上的泛型：静态方法无法访问类上定义的泛型。如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。
&&&public static&Q& void function(Q t) {
&&&&&&&System.out.println(&function:&+t);
//泛型接口.
interface Inter&T& {
&&&void show(T t);
class InterImpl&R& implements Inter&R& {
&&&public void show(R r) {
&&&&&&&System.out.println(&show:&+r);
------------------------------------------------------------
泛型中的通配符：可以解决当具体类型不确定的时候，这个通配符就是?&；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用?
通配符来表未知类型。
泛型限定：
&&&上限：？extends E：可以接收E类型或者E的子类型对象。
&&&下限：？super E：可以接收E类型或者E的父类型对象。
上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。
下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。
泛型的细节：
1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；
2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；
&&&原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；
3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；
ArrayList&String&al = new ArrayList&Object&();&//错
//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。
ArrayList&?extends Object& al = new ArrayList&String&();
al.add(&aa&);&//错
//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。
？extendsObject 代表Object的子类型不确定，怎么能添加具体类型的对象呢？
public static voidmethod(ArrayList&? extends Object& al) {
al.add(&abc&);&//错
&//只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。
java.lang.System:属性和行为都是静态的。
返回当前时间毫秒值
//退出虚拟机
获取当前系统的属性信息
获取系统的属性信息，并将这些信息存储到集合中。
毕老师给系统属性信息集添加具体的属性信息
临时设置方式：运行时，可以通过的参数进行系统属性的临时设置，可以在命令的后面加入用法：小明类名。
;//获取指定属性的信息
想要知道该系统是否是该软件所支持的系统中的一个。
System.out.println(&可以支持
System.out.println(&不支持
java.lang.Runtime:类中没有构造方法，不能创建对象。
但是有非静态方法。说明该类中应该定义好了对象，并可以通过一个方法获取这个对象。用这个对象来调用非静态方法。这个方法就是
这个其实使用单例设计模式进行设计。
RuntimeDemo {
publicstatic void main(String[] args) throws Exception {
Runtimer = Runtime.getRuntime();
Processp = r.exec(&notepad.exe SystemDemo.java&);&//运行指定的程序
Thread.sleep(4000);
p.destroy();&
//杀掉进程
java.util.Math:用于数学运算的工具类，属性和行为都是静态的。该类是不允许继承。
返回大于指定数值的最小整数
返回小于指定数值的最大整数
四舍五入成整数
返回的伪随机数
publicstatic void main(String[] args) {
Randomr = new Random();
for(intx=0; x&10; x++) {
//doubled = Math.floor(Math.random()*10+1);
= (int)(Math.random()*10+1);
intd = r.nextInt(10)+1;
System.out.println(d);
java.util.Date：日期类，月份从；
日期对象和毫秒值之间的转换。
1，日期对象转成毫秒值。类中的方法。
2，如何将获取到的毫秒值转成具体的日期呢？
Date类中的方法。也可以通过构造函数。
//日期对象转成毫秒值
Dated = new Date();
longtime1 = d.getTime();
longtime2 = System.currentTimeMillis(); / /毫秒值。
//毫秒值转成具体的日期
longtime = 2l;
Dated = new Date();
d.setTime(time);
将日期字符串转换成日期对象：使用的就是方法中的Date
parse(String source) ；
publicstatic void method() throws Exception {
Stringstr_time = &&;
DateFormat df = new SimpleDateFormat(&yyyy/MM/dd&);//SimpleDateFormat作为可以指定用户自定义的格式来完成格式化。
Date d = df.parse(str_time);
如果不需要使用特定的格式化风格，完全可以使用类中的静态工厂方法获取具体的已经封装好风格的对象。
Dated = new Date();
DateFormatdf = DateFormat.getDateInstance(DateFormat.LONG);
df= DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
Stringstr_time = df.format(d);
//将日期对象转换成字符串的方式：类中的方法。
//创建日期格式对象。
DateFormat df = new SimpleDateFormat();
//该对象的建立内部会封装一个默认的日期格式。下午
//如果想要自定义日期格式的话。可使用的构造函数。将具体的格式作为参数传入到构造函数中。如何表示日期中年的部分呢？可以必须要参与格式对象文档。
df = newSimpleDateFormat(&yyyy年月日
//调用中的方法。对已有的日期对象进行格式化。
String str_time = df.format(d);
java.util.
Calendar：日历类
publicstatic void method(){
Calendarc = Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR)+&年月
+getNum(c.get(Calendar.DAY_OF_MONTH))+&日
+&星期
publicstatic String getNum(int num){
returnnum&9 ? num+&& : &0&+
publicstatic String getWeek(int index){
查表法：建立数据的对应关系
最好：数据个数是确定的，而且有对应关系。如果对应关系的一方，是数字，而且可以作为角标，那么可以通过数组来作为表。
String[]weeks = {&&,&日一二三四五六
returnweeks[index];
本文标题：
本页链接：}