Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 1.1 Source Code Directory
JDK 1.1 source code directory contains Java source code for JDK 1.1 core classes: "C:\fyicenter\jdk-1.1.8\src".
Here is the list of Java classes of the JDK 1.1 source code:
✍: FYIcenter
⏎ java/text/CollationKey.java
/* * @(#)CollationKey.java 1.4 97/01/28 * * (C) Copyright Taligent, Inc. 1996 - All Rights Reserved * (C) Copyright IBM Corp. 1996 - All Rights Reserved * * Portions copyright (c) 2002 Sun Microsystems, Inc. All Rights Reserved. * * The original version of this source code and documentation is copyrighted * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These * materials are provided under terms of a License Agreement between Taligent * and Sun. This technology is protected by multiple US and International * patents. This notice and attribution to Taligent may not be removed. * Taligent is a registered trademark of Taligent, Inc. * * Permission to use, copy, modify, and distribute this software * and its documentation for NON-COMMERCIAL purposes and without * fee is hereby granted provided that this copyright notice * appears in all copies. Please refer to the file "copyright.html" * for further important copyright and licensing information. * * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. * */ package java.text; /** * A <code>CollationKey</code> represents a <code>String</code> under the * rules of a specific <code>Collator</code> object. Comparing two * <code>CollationKey</code>s returns the relative order of the * <code>String</code>s they represent. Using <code>CollationKey</code>s * to compare <code>String</code>s is generally faster than using * <code>Collator.compare</code>. Thus, when the <code>String</code>s * must be compared multiple times, for example when sorting a list * of <code>String</code>s. It's more efficient to use <code>CollationKey</code>s. * * <p> * You can not create <code>CollationKey</code>s directly. Rather, * generate them by calling <code>Collator.getCollationKey</code>. * You can only compare <code>CollationKey</code>s generated from * the same <code>Collator</code> object. * * <p> * Generating a <code>CollationKey</code> for a <code>String</code> * involves examining the entire <code>String</code> * and converting it to series of bits that can be compared bitwise. This * allows fast comparisons once the keys are generated. The cost of generating * keys is recouped in faster comparisons when <code>String</code>s need * to be compared many times. On the other hand, the result of a comparison * is often determined by the first couple of characters of each <code>String</code>. * <code>Collator.compare</code> examines only as many characters as it needs which * allows it to be faster when doing single comparisons. * <p> * The following example shows how <code>CollationKey</code>s might be used * to sort a list of <code>String</code>s. * <blockquote> * <pre> * // Create an array of CollationKeys for the Strings to be sorted. * Collator myCollator = Collator.getInstance(); * CollationKey[] keys = new CollationKey[3]; * keys[0] = myCollator.getCollationKey("Tom"); * keys[1] = myCollator.getCollationKey("Dick"); * keys[2] = myCollator.getCollationKey("Harry"); * sort( keys ); * <nsbr> * //... * <nsbr> * // Inside body of sort routine, compare keys this way * if( keys[i].compareTo( keys[j] ) > 0 ) * // swap keys[i] and keys[j] * <nsbr> * //... * <nsbr> * // Finally, when we've returned from sort. * System.out.println( keys[0].getSourceString() ); * System.out.println( keys[1].getSourceString() ); * System.out.println( keys[2].getSourceString() ); * </pre> * </blockquote> * * @see Collator * @see RuleBasedCollator * @version 1.4 28 Jan 1997 * @author Helena Shih */ public final class CollationKey { /** * Compare this CollationKey to the target CollationKey. The collation rules of the * Collator object which created these keys are applied. <strong>Note:</strong> * CollationKeys created by different Collators can not be compared. * @param target target CollationKey * @return Returns an integer value. Value is less than zero if this is less * than target, value is zero if this and target are equal and value is greater than * zero if this is greater than target. * @see java.text.Collator#compare */ public int compareTo(CollationKey target) { int result = key.compareTo(target.key); if (result <= Collator.LESS) return Collator.LESS; else if (result >= Collator.GREATER) return Collator.GREATER; return Collator.EQUAL; } /** * Compare this CollationKey and the target CollationKey for equality. * The collation rules of the Collator object which created these keys are applied. * <strong>Note:</strong> CollationKeys created by different Collators can not be * compared. * @param target the CollationKey to compare to. * @return Returns true if two objects are equal, false otherwise. */ public boolean equals(Object target) { if (this == target) return true; if (target == null || !getClass().equals(target.getClass())) { return false; } CollationKey other = (CollationKey)target; return key.equals(other.key); } /** * Creates a hash code for this CollationKey. The hash value is calculated on the * key itself, not the String from which the key was created. Thus * if x and y are CollationKeys, then x.hashCode(x) == y.hashCode() if * x.equals(y) is true. This allows language-sensitive comparison in a hash table. * See the CollatinKey class description for an example. * @return the hash value based on the string's collation order. */ public int hashCode() { return (key.hashCode()); } /** * Returns the String that this CollationKey represents. */ public String getSourceString() { return source; } /** * Converts the CollationKey to a sequence of bits. If two CollationKeys * could be legitimately compared, then one could compare the byte arrays * for each of those keys to obtain the same result. Byte arrays are * organized most significant byte first. */ public byte[] toByteArray() { char[] src = key.toCharArray(); byte[] dest = new byte[ 2*src.length ]; int j = 0; for( int i=0; i<src.length; i++ ) { dest[j++] = (byte)(src[i] >>> 8); dest[j++] = (byte)(src[i] & 0x00ff); } return dest; } /** * A CollationKey can only be generated by Collator objects. */ CollationKey(String source, String key) { this.source = source; this.key = key; } private String source = null; private String key = null; }
⏎ java/text/CollationKey.java
Or download all of them as a single archive file:
File name: jdk-1.1.8-src.zip File size: 1574187 bytes Release date: 2018-11-16 Download
⇒ Backup JDK 1.1 Installation Directory
2018-11-17, 150745👍, 0💬
Popular Posts:
Apache Log4j SLF4J Binding allows applications coded to the SLF4J API to use Log4j 2 as the implemen...
The Bouncy Castle Crypto package is a Java implementation of cryptographic algorithms, it was develo...
JDOM provides a solution for using XML from Java that is as simple as Java itself. There is no compe...
What Is poi-contrib-3.5.jar? poi-contrib-3.5.jar is one of the JAR files for Apache POI 3.5, which p...
iText is an ideal library for developers looking to enhance web- and other applications with dynamic...