javaheadset的简单介绍
本篇文章给大家谈谈javaheadset，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
java有哪些有序集合？
Comparable接口
Comparator接口
SortedSet接口
SortedMap接口
在集合框架中有许多类具有排序功能，如：TreeSet类TreeMap类
为了用“集合框架”的额外部分把排序支持添加到Java2 SDK，版本1.2，核心Java库作了许多更改。像String和Integer类如今实现Comparable接口以提供自然排序顺序。对于那些没有自然顺序的类、或者当您想要一个不同于自然顺序的顺序时，您可以实现Comparator接口来定义您自己的。
Comparable接口
适用于一个类有自然顺序的时候（对于这个自然顺序的理解，我觉得是这样：Comparable中只有一个方法compareTo（），它是比较当前实例和作为参数传入的元素，一个实例，一个参数，说明实例和参数自然具有可比较性）。
下面是Comparable接口的定义：
package java.lang; import java.util.*; public interfaceComparableT { publicintcompareTo(T o); }
compareTo()方法：如果排序过程中当前实例出现在参数前，就返回某个负值。如果当前实例出现在参数后，则返回正值。否则，返回零。这里不要求零返回值表示元素相等。零返回值只是表示两个对象排在同一个位置。
Java1.6中实现了Comparable接口的类大概有50左右个。
Comparator接口
有些类是不能用于实现java.lang.Comparable，这时我们可以提供自己的java.lang.Comparator行为。或者，如果你不喜欢缺省的Comparable行为，你也照样可以提供自己的Comparator。
package java.lang; import java.util.*; public interface ComparableT { public int compareTo(T o); } 实例： import java.util.Comparator; import java.util.Iterator; import java.util.Set; import java.util.TreeSet; /** * 10、 定义一个学生类, 需要有姓名, 年龄, 考试成绩三个成员属性， * 创建5个对象, 属性可为任意值. 编程对这5个对象按成绩排序，并将结果输出。 * （提示，用TreeSet和Comparator实现） * * *******************按成绩小大排序**************** * @author jin * */ public class Test10 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Student_ stu1=new Student_("Joyce", 21, 98); Student_ stu2=new Student_("kelvin", 25, 95); Student_ stu3=new Student_("kelvun", 29, 89); Student_ stu4=new Student_("Judy", 25, 92); Student_ stu5=new Student_("phil", 43, 93); // 创建TreeSet SetStudent_ st=new TreeSetStudent_(new Student_.TestScoresCompareStudent_()); st.add(stu5); st.add(stu4); st.add(stu3); st.add(stu2); st.add(stu1); //遍历 IteratorStudent_ it=st.iterator(); while(it.hasNext()){ Student_ student=it.next(); System.out.println(student.getName()+" : "+student.getAge()+" : "+student.getTest_scores()); } } } class Student_{ // 三个属性 private String name; private int age; private int test_scores; public String getName(){ return this.name; } public int getAge(){ return this.age; } public int getTest_scores(){ return this.test_scores; } Student_(String name, int age, int test_scores){// 构造器 this.name=name; this.age=age; this.test_scores=test_scores; } // 这里为什么要用静态类呢？ static class TestScoresCompareT implements ComparatorT{ // 注意：ComparatorT是泛型，实现了这个接口的类也要是泛型 //// 实现比较器 @Override public int compare(T o1, T o2) { Student_ stu1=(Student_)o1; Student_ stu2=(Student_)o2; if(stu1.test_scoresstu2.test_scores){ return 1; } return -1; } } // 泛型参数可以出现在：类，接口，成员方法，内嵌类（接口）中 }
另外，“集合框架”提供了两个特殊的接口：SortedSet接口 和 SortMap接口
SortedSet接口
接口为集的子集和它的两端（即头和尾）提供了访问方法。
从treeSet类的定义中可以发现，TreeSet中实现了SortedSet接口.
添加到SortedSet中的元素必须实现Comparable接口。或者你必须给他的实现类的构造函数提供一个Comparator（上面那个实例就是这样呀）。
如果添加元素时比较两个元素导致了零返回值，那么新元素就没有添加进去。
public interface SortedSetE extends SetE { Comparator? super E comparator(); // 返回与排序有关联的比较器 SortedSetE subSet(E fromElement, E toElement); // 返回指定对象间的元素 SortedSetE headSet(E toElement); // 返回从开始到指定元素的集合 SortedSetE tailSet(E fromElement); E first(); E last(); }
SortedMap接口
用来保持键Key的有序。
和上面的SortedSet接口类似，为映射的子集包括两个端点提供了访问方法。
TreeMap中实现了SortMap接口。
如果在添加一个键-值对时比较两个键产生了零返回值，那么，原始键对应值被新的值替代。
java的set集合：不知为何最后输出的是乱码。。。
你下面输出来的是地址吧，改成这样：
for(int i=0;ia.length;i++)
{
System.out.println(a[i].getId()+" "+a[i].getName());
}
android 蓝牙 怎么入门
入手一个新的模块或应用，当然首先要知道它都有什么了，与它相关的代码在那里，所以先一起看下蓝牙代码分布吧。
1. 代码分布：
packages/apps/Bluetooth/
看这路径肯定是蓝牙应用方面的代码了，主要是关于蓝牙应用协议的表现代码，包括opp、hfp、hdp、a2dp、pan等等，这些名词后面再解释。
frameworks/base/core/java/android/server/
4.2以后这个目录虽然还有了，但里面代码已经转移到应用层了，就是前面那个目录，所以4.2.2上的蓝牙这里可以忽略。
framework/base/core/java/android/bluetooth
这个目录里的代码更像一个桥梁，里面有供java层使用一些类，也有对应的aidl文件联系C、C++部分的代码，还是挺重要的。
kernel\drivers\bluetoothBluetooth
具体协议实现。包括hci,hid，rfcomm,sco,SDP等协议
kernel\net\bluetooth Linux kernel
对各种接口的Bluetoothdevice的驱动。例如：USB接口，串口等，上面kernel这两个目录有可能看不到的，但一定会有的。
external\bluetooth\bluedroid BlueZ (应用空间协议)，官方蓝牙协议栈。
system\bluetoothBluetooth 适配层代码，和framework那个作用类似，是串联framework与blueZ的工具。
大致代码分布就是这些，初步查看后让我们再来看下蓝牙的整体结构。
2.整体结构：
这部分直接上图了，看着直观些。图中把JNI部分虽然在目前4.2的代码中在packages层，这里还是画在Framework层了，说明下希望
不要引起理解的误会。从图上可以感觉到整体流程和以前变化不大，所以流程方面的文章看4.1或更早的应该问题也不大。
PS：上图关于蓝牙协议栈的说明有误，4.2里已经不再是bluez了，在些更正一下，当然协议栈这一部分还是要有的，新的协议栈看下面英文：
Android 4.2 introduces a new Bluetooth stack optimized for use with Android devices. The new Bluetooth stack developed in
collaboration between Google and Broadcom replaces the stack based on BlueZ and provides improved compatibility and reliability.
google和broadcom合作开发了一个新蓝牙协议栈，老版本的兼容性问题在所难免了。在此感谢网友andger032的提醒。
3.常用类和名词解释：
\packages\apps\Settings\src\com\android\settings\bluetooth 目录下
BluetoothEnabler.java 界面上蓝牙开启、关闭的开关就是它了，
BluetoothSettings.java 主界面，用于管理配对和连接设备
LocalBluetoothManager.java 提供了蓝牙API上的简单调用接口，这里只是开始。
CachedBluetoothDevice.java 描述蓝牙设备的类，对BluetoothDevice的再封装
BluetoothPairingDialog.java 那个配对提示的对话框
/packages/apps/Phone/src/com/android/phone/
BluetoothPhoneService.java 在phone的目录肯定和电话相关了，蓝牙接听挂断电话会用到这个
/packages/apps/Bluetooth/src/com/android/bluetooth/btservice/
AdapterService.java 4.2后才有的代码，蓝牙打开、关闭、扫描、配对都会走到这里，其实更准确的说它替代了4.1之前的BluetoothService.java，原来的工作就由这个类来完成了。说到这里不能不说4.2蓝牙的目录变了，在4.1及以前的代码中packages层的代码只有opp协议相关应用的代码，也就是文件传输那部分，而4.2的代码应用层的代码则丰富了许多，按具体的蓝牙应用协议来区别，分为以下文件夹（这里一并对蓝牙一些名词作个简单解释）：
a2dp 蓝牙立体声，和蓝牙耳机听歌有关那些，另还有个avrcp--音频/视频远程控制配置文件，是用来听歌时暂停，上下歌曲选择的。
btservice 这个前面AdapterService.java的描述大家应该能猜到一些，关于蓝牙基本操作的目录，一切由此开始。
hdp 蓝牙关于医疗方面的应用 Bluetooth Health Device Profile
hfp 和电话相关，蓝牙接听、挂断电话 Hands-free Profile
hid 人机交互接口，蓝牙鼠标键盘什么的就是这个了
opp 不多解释，以前就有。
pan 描述了两个或更多个 Bluetooth 设备如何构成一个即时网络，和网络有关的还有串行端口功能(SPP)，拨号网络功能(DUN)
pbap 电话号码簿访问协议(Phonebook Access Profile)
android 4.2的蓝牙应用层部分代码更丰富了，虽然有些目录还没具体代码，不过说不准哪个版本更新就有了，就像4.0添加了hdp医疗那部分一样。
另外原本在framework的JNI代码也被移到packages/apps/bluetooth当中。
/frameworks/base/core/java/android/bluetooth/目录下
BluetoothA2dp.java A2DP的功能实现
BluetoothAdapter.java 蓝牙action的定义，虚拟设备属性以及操作方法
BluetoothAudioGateway.java 蓝牙语音网关
BluetoothClass.java 蓝牙设备类型的定义
BluetoothDevice.java 蓝牙设备属性
BluetoothDevicePicker.java 定义远程蓝牙设备的特性，比如需要认证，设备类型
BluetoothHeadset.java 定义蓝牙headset功能的属性以及接口
BluetoothInputStream.java 蓝牙流接口的实现（输入流）
BluetoothOutputStream.java 蓝牙流接口的实现（输出流）
BluetoothServerSocket.java 蓝牙socket服务端具备的方法
BluetoothSocket.java 蓝牙socket的封装
BluetoothUuid.java 蓝牙uuid的定义以及uuid的解析
以上java文件在使用具体功能会用到，现在只是简单描述下，至于具体使用在后续文章用到时再给出。同时代码说明部分也就写这些了
对于C、C++部分的代码一方面没看那么多，另一方面根据android JNI的命名习惯，大家找起来也很容易。
4.后续分析：
前面从整体上描述蓝牙的基本知识，落实在具体的代码分析上，我们按几个主线功能来走，蓝牙的开关、搜索配对、蓝牙耳机与电话和文件传输，
这几个也算是蓝牙的常用必备功能了，所以在后续文章中将按着这个顺序来跟一下它们代码调用流程。希望可以让你快速的了解蓝牙，当然如果有失误
转载
java 小题目
package util;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* p
* 操作集合的类，可以返回以读写锁实现的各类集合br
* /p
*
*/
public class CollectionUtils {
private CollectionUtils() {}
/**
* p
* 返回用读写锁实现的集合
* /p
*
* @param collection
* 基础集合
* @return 同步集合
*/
public static T CollectionT readWriteLockCollection(
CollectionT collection) {
return new ReadWriteLockCollectionT(collection);
}
/**
* p
* 返回用读写锁实现的List
* /p
*
* @param list
* 基础List
* @return 同步List
*/
public static T ListT readWriteLockList(ListT list) {
return new ReadWriteLockListT(list);
}
/**
* p
* 返回用读写锁实现的Set
* /p
*
* @param set
* 基础Set
* @return 同步Set
*/
public static T SetT readWriteLockSet(SetT set) {
return new ReadWriteLockSetT(set);
}
/**
* p
* 返回用读写锁实现的SortedSet
* /p
*
* @param sortedSet
* 基础SortedSet
* @return 同步SortedSet
*/
public static T SortedSetT readWriteLockSortedSet(SortedSetT sortedSet) {
return new ReadWriteLockSortedSetT(sortedSet);
}
/**
* p
* 返回用读写锁实现的Map
* /p
*
* @param map
* 基础Map
* @return 同步Map
*/
public static K, V MapK, V readWriteLockMap(MapK, V map) {
return new ReadWriteLockMapK, V(map);
}
/**
* p
* 返回用读写锁实现的SortedMap
* /p
*
* @param sortedMap
* 基础SortedMap
* @return 同步SortedMap
*/
public static K, V SortedMapK, V readWriteLockSortedMap(
SortedMapK, V sortedMap) {
return new ReadWriteLockSortedMapK, V(sortedMap);
}
private static class ReadWriteLockCollectionT implements CollectionT {
private CollectionT collection;
protected ReadWriteLock lock = new ReentrantReadWriteLock();
private ReadWriteLockCollection(CollectionT collection) {
if (collection == null)
throw new NullPointerException();
this.collection = collection;
}
@Override
public boolean add(T e) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.add(e);
} finally {
lock.unlock();
}
}
@Override
public boolean addAll(Collection? extends T c) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.addAll(c);
} finally {
lock.unlock();
}
}
@Override
public void clear() {
Lock lock = this.lock.writeLock();
lock.lock();
try {
collection.clear();
} finally {
lock.unlock();
}
}
@Override
public boolean contains(Object o) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.contains(o);
} finally {
lock.unlock();
}
}
@Override
public boolean containsAll(Collection? c) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.containsAll(c);
} finally {
lock.unlock();
}
}
@Override
public boolean isEmpty() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.isEmpty();
} finally {
lock.unlock();
}
}
@Override
public IteratorT iterator() {
return collection.iterator();
}
@Override
public boolean remove(Object o) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.remove(o);
} finally {
lock.unlock();
}
}
@Override
public boolean removeAll(Collection? c) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.removeAll(c);
} finally {
lock.unlock();
}
}
@Override
public boolean retainAll(Collection? c) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.retainAll(c);
} finally {
lock.unlock();
}
}
@Override
public int size() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.size();
} finally {
lock.unlock();
}
}
@Override
public Object[] toArray() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.toArray();
} finally {
lock.unlock();
}
}
@Override
public E E[] toArray(E[] a) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.toArray(a);
} finally {
lock.unlock();
}
}
}
private static class ReadWriteLockListT extends
ReadWriteLockCollectionT implements ListT {
private ListT list;
private ReadWriteLockList(ListT list) {
super(list);
this.list = list;
}
@Override
public void add(int index, T element) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
list.add(index, element);
} finally {
lock.unlock();
}
}
@Override
public boolean addAll(int index, Collection? extends T c) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return list.addAll(index, c);
} finally {
lock.unlock();
}
}
@Override
public T get(int index) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return list.get(index);
} finally {
lock.unlock();
}
}
@Override
public int indexOf(Object o) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return list.indexOf(o);
} finally {
lock.unlock();
}
}
@Override
public int lastIndexOf(Object o) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return list.lastIndexOf(o);
} finally {
lock.unlock();
}
}
@Override
public ListIteratorT listIterator() {
return list.listIterator();
}
@Override
public ListIteratorT listIterator(int index) {
return list.listIterator(index);
}
@Override
public T remove(int index) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return list.remove(index);
} finally {
lock.unlock();
}
}
@Override
public T set(int index, T element) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return list.set(index, element);
} finally {
lock.unlock();
}
}
@Override
public ListT subList(int fromIndex, int toIndex) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockListT(
list.subList(fromIndex, toIndex));
} finally {
lock.unlock();
}
}
}
private static class ReadWriteLockSetT extends ReadWriteLockCollectionT
implements SetT {
private ReadWriteLockSet(SetT set) {
super(set);
}
}
private static class ReadWriteLockSortedSetT extends ReadWriteLockSetT
implements SortedSetT {
private SortedSetT sortedSet;
private ReadWriteLockSortedSet(SortedSetT sortedSet) {
super(sortedSet);
this.sortedSet = sortedSet;
}
@Override
public Comparator? super T comparator() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedSet.comparator();
} finally {
lock.unlock();
}
}
@Override
public T first() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedSet.first();
} finally {
lock.unlock();
}
}
@Override
public SortedSetT headSet(T toElement) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedSetT(
sortedSet.headSet(toElement));
} finally {
lock.unlock();
}
}
@Override
public T last() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedSet.last();
} finally {
lock.unlock();
}
}
@Override
public SortedSetT subSet(T fromElement, T toElement) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedSetT(sortedSet.subSet(
fromElement, toElement));
} finally {
lock.unlock();
}
}
@Override
public SortedSetT tailSet(T fromElement) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedSetT(
sortedSet.tailSet(fromElement));
} finally {
lock.unlock();
}
}
}
private static class ReadWriteLockMapK, V implements MapK, V {
private MapK, V map;
protected ReadWriteLock lock = new ReentrantReadWriteLock();
private ReadWriteLockMap(MapK, V map) {
if (map == null)
throw new NullPointerException();
this.map = map;
}
@Override
public void clear() {
Lock lock = this.lock.writeLock();
lock.lock();
try {
map.clear();
} finally {
lock.unlock();
}
}
@Override
public boolean containsKey(Object key) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.containsKey(key);
} finally {
lock.unlock();
}
}
@Override
public boolean containsValue(Object value) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.containsValue(value);
} finally {
lock.unlock();
}
}
@Override
public Setjava.util.Map.EntryK, V entrySet() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSetjava.util.Map.EntryK, V(
map.entrySet());
} finally {
lock.unlock();
}
}
@Override
public V get(Object key) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.get(key);
} finally {
lock.unlock();
}
}
@Override
public boolean isEmpty() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.isEmpty();
} finally {
lock.unlock();
}
}
@Override
public SetK keySet() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSetK(map.keySet());
} finally {
lock.unlock();
}
}
@Override
public V put(K key, V value) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return map.put(key, value);
} finally {
lock.unlock();
}
}
@Override
public void putAll(Map? extends K, ? extends V m) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
map.putAll(m);
} finally {
lock.unlock();
}
}
@Override
public V remove(Object key) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return map.remove(key);
} finally {
lock.unlock();
}
}
@Override
public int size() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.size();
} finally {
lock.unlock();
}
}
@Override
public CollectionV values() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockCollectionV(map.values());
} finally {
lock.unlock();
}
}
}
private static class ReadWriteLockSortedMapK, V extends
ReadWriteLockMapK, V implements SortedMapK, V {
private SortedMapK, V sortedMap;
private ReadWriteLockSortedMap(SortedMapK, V sortedMap) {
super(sortedMap);
this.sortedMap = sortedMap;
}
@Override
public Comparator? super K comparator() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedMap.comparator();
} finally {
lock.unlock();
}
}
@Override
public K firstKey() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedMap.firstKey();
} finally {
lock.unlock();
}
}
@Override
public SortedMapK, V headMap(K toKey) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedMapK, V(
sortedMap.headMap(toKey));
} finally {
lock.unlock();
}
}
@Override
public K lastKey() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedMap.lastKey();
} finally {
lock.unlock();
}
}
@Override
public SortedMapK, V subMap(K fromKey, K toKey) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedMapK, V(sortedMap.subMap(
fromKey, toKey));
} finally {
lock.unlock();
}
}
@Override
public SortedMapK, V tailMap(K fromKey) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedMapK, V(
sortedMap.tailMap(fromKey));
} finally {
lock.unlock();
}
}
}
}
关于javaheadset和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。