Learning Java, 4th Edition

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

Learning Java, 4th Edition

Book Description
Java is the preferred language for many of today's leading-edge technologies—everything from smartphones and game consoles to robots, massive enterprise systems, and supercomputers. If you're new to Java, the fourth edition of this bestselling guide provides an example-driven introduction to the latest language features and APIs in Java 6 and 7. Advanced Java developers will be able to take a deep dive into areas such as concurrency and JVM enhancements.

You'll learn powerful new ways to manage resources and exceptions in your applications, and quickly get up to speed on Java's new concurrency utilities, and APIs for web services and XML. You'll also find an updated tutorial on how to get started with the Eclipse IDE, and a brand-new introduction to database access in Java.
Book Details

• Publisher:        O'Reilly Media
• By:        Patrick Niemeyer, Daniel Leuck
• ISBN:        978-1-44931-924-3
• Year:        2013
• Pages:        1010
• Language:        English
• File size:        25.7 MB
• File format:        PDF
• Download:       

  本帖隐藏的内容

  Learning Java, 4th Edition.pdf (24.55 MB, 需要: 20 个论坛币)

  2015-4-12 06:28:10 上传

  
  需要: 20 个论坛币  [购买]
  
  
  

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享2 收藏12 回帖

关键词：Learning Edition earning editio dition everything features provides systems latest

StringBuilder and StringBuffer

In contrast to the immutable string, the java.lang.StringBuilder class is a modifiable and expandable buffer for characters. You can use it to create a big string efficiently. StringBuilder andStringBuffer are twins; they have exactly the same API. StringBuilder was added in Java 5.0 as a drop-in, unsynchronized replacement for StringBuffer. We’ll come back to that in a bit.

First, let’s look at some examples of String construction:

1.     // Could be better
   
2.     String ball = "Hello";
   
3.     ball = ball + " there.";
   
4.     ball = ball + " How are you?";

复制代码

This example creates an unnecessary String object each time we use the concatenation operator (+). Whether this is significant depends on how often this code is run and how big the string actually gets. Here’s a more extreme example:

   

1. // Bad use of + ...
   
2.     while( (line = readLine()) != EOF )
   
3.         text += line;

复制代码

This example repeatedly produces new String objects. The character array must be copied over and over, which can adversely affect performance. The solution is to use a StringBuilder object and itsappend() method:

   

1. StringBuilder sb = new StringBuilder("Hello");
   
2.     sb.append(" there.");
   
3.     sb.append(" How are you?");
   
4. 
   
5.     StringBuilder text = new StringBuilder();
   
6.     while( (line = readline()) != EOF )
   
7.         text.append( line );

复制代码

Here, the StringBuilder efficiently handles expanding the array as necessary. We can get a String back from the StringBuilder with its toString() method:

1.   String message = sb.toString();

复制代码

You can also retrieve part of a StringBuilder as a String by using one of the substring() methods.

You might be interested to know that when you write a long expression using string concatenation, the compiler generates code that uses a StringBuilder behind the scenes:

1.   String foo = "To " + "be " + "or";

复制代码

It is really equivalent to:

    String foo = new      StringBuilder().append("To ").append("be ").append("or").toString();

In this case, the compiler knows what you are trying to do and takes care of it for you.

The StringBuilder class provides a number of overloaded append() methods for adding any type of data to the buffer. StringBuilder also provides a number of overloaded insert() methods for inserting various types of data at a particular location in the string buffer. Furthermore, you can remove a single character or a range of characters with the deleteCharAt() and delete() methods. Finally, you can replace part of the StringBuilder with the contents of a String using the replace() method. The String and StringBuilder classes cooperate so that, in some cases, no copy of the data has to be made; the string data is shared between the objects.

You should use a StringBuilder instead of a String any time you need to keep adding characters to a string; it’s designed to handle such modifications efficiently. You can convert the StringBuilder to a String when you need it, or simply concatenate or print it anywhere you’d use a String.

As we said earlier, StringBuilder was added in Java 5.0 as a replacement for StringBuffer. The only real difference between the two is that the methods of StringBuffer are synchronized and the methods of StringBuilder are not. This means that if you wish to use StringBuilder from multiple threads concurrently, you must synchronize the access yourself (which is easily accomplished). The reason for the change is that most simple usage does not require any synchronization and shouldn’t have to pay the associated penalty (slight as it is).

Method

Functionality

charAt()

Gets a particular character in the string

compareTo()

Compares the string with another string

concat()

Concatenates the string with another string

contains()

Checks whether the string contains another string

copyValueOf()

Returns a string equivalent to the specified character array

endsWith()

Checks whether the string ends with a specified suffix

equals()

Compares the string with another string

equalsIgnoreCase()

Compares the string with another string, ignoring case

getBytes()

Copies characters from the string into a byte array

getChars()

Copies characters from the string into a character array

hashCode()

Returns a hashcode for the string

indexOf()

Searches for the first occurrence of a character or substring in the string

intern()

Fetches a unique instance of the string from a global shared-string pool

isEmpty()

Returns true if the string is zero length

lastIndexOf()

Searches for the last occurrence of a character or substring in a string

length()

Returns the length of the string

matches()

Determines if the whole string matches a regular expression pattern

regionMatches()

Checks whether a region of the string matches the specified region of another string

replace()

Replaces all occurrences of a character in the string with another character

replaceAll()

Replaces all occurrences of a regular expression pattern with a pattern

replaceFirst()

Replaces the first occurrence of a regular expression pattern with a pattern

split()

Splits the string into an array of strings using a regular expression pattern as a delimiter

startsWith()

Checks whether the string starts with a specified prefix

substring()

Returns a substring from the string

toCharArray()

Returns the array of characters from the string

toLowerCase()

Converts the string to lowercase

toString()

Returns the string value of an object

toUpperCase()

Converts the string to uppercase

trim()

Removes leading and trailing whitespace from the string

valueOf()

Returns a string representation of a value

Swing is Java’s graphical user interface toolkit. The javax.swing package (and its numerous subpackages) contain classes representing interface items such as windows, buttons, combo boxes, trees, tables, and menus—everything you need to build a modern, rich client-side application.

Swing is part of a larger collection of software called the Java Foundation Classes (JFC), which includes the following APIs:

• The Abstract Window Toolkit (AWT), the original user interface toolkit and base graphics classes

• Swing, the pure Java user interface toolkit

• Accessibility, which provides tools for integrating nonstandard input and output devices into your user interfaces

• The 2D API, a comprehensive set of classes for high-quality drawing

• Drag and Drop, an API that supports the drag-and-drop metaphor

  
  

JFC is one of the largest and most complex parts of the standard Java platform, so it shouldn’t be any surprise that we’ll take several chapters to discuss it. In fact, we won’t even get to talk about all of it, just the most important parts—Swing and the 2D API.

1. //file: ObserveImageLoad.java
   
2.     import java.awt.*;
   
3.     import java.awt.image.*;
   
4. 
   
5.     public class ObserveImageLoad {
   
6. 
   
7.       public static void main( String [] args)
   
8.       {
   
9.        ImageObserver myObserver = new ImageObserver() {
   
10.           public boolean imageUpdate(
    
11.              Image image, int flags, int x, int y, int width, int height)
    
12.           {
    
13.              if ( (flags & HEIGHT) !=0 )
    
14.                System.out.println("Image height = " + height );
    
15.              if ( (flags & WIDTH ) !=0 )
    
16.                System.out.println("Image width = " + width );
    
17.              if ( (flags & FRAMEBITS) != 0 )
    
18.                System.out.println("Another frame finished.");
    
19.              if ( (flags & SOMEBITS) != 0 )
    
20.                 System.out.println("Image section :"
    
21.                     + new Rectangle( x, y, width, height ) );
    
22.              if ( (flags & ALLBITS) != 0 )
    
23.                System.out.println("Image finished!");
    
24.              if ( (flags & ABORT) != 0 )
    
25.                System.out.println("Image load aborted...");
    
26.              return true;
    
27.          }
    
28.        };
    
29. 
    
30.         Toolkit toolkit = Toolkit.getDefaultToolkit();
    
31.         Image img = toolkit.getImage( args[0] );
    
32.         toolkit.prepareImage( img, -1, -1, myObserver );
    
33.       }
    
34.     }

复制代码

1. Here is its source code:
   
2. 
   
3.     //file: Hypnosis.java
   
4.     import java.awt.*;
   
5.     import java.awt.event.*;
   
6.     import java.awt.geom.GeneralPath;
   
7.     import javax.swing.*;
   
8. 
   
9.     public class Hypnosis extends JComponent implements Runnable {
   
10.       private int[] coordinates;
    
11.       private int[] deltas;
    
12.       private Paint paint;
    
13. 
    
14.       public Hypnosis(int numberOfSegments) {
    
15.         int numberOfCoordinates = numberOfSegments * 4 + 2;
    
16.         coordinates = new int[numberOfCoordinates];
    
17.         deltas = new int[numberOfCoordinates];
    
18.         for (int i = 0 ; i < numberOfCoordinates; i++) {
    
19.           coordinates[i] = (int)(Math.random() * 300);
    
20.           deltas[i] = (int)(Math.random() * 4 + 3);
    
21.           if (deltas[i] > 4) deltas[i] = -(deltas[i] - 3);
    
22.         }
    
23.         paint = new GradientPaint(0, 0, Color.BLUE,
    
24.             20, 10, Color.RED, true);
    
25. 
    
26.         Thread t = new Thread(this);
    
27.         t.start();
    
28.       }
    
29. 
    
30.       public void run() {
    
31.         try {
    
32.           while (true) {
    
33.             timeStep();
    
34.             repaint();
    
35.             Thread.sleep(1000 / 24);
    
36.           }
    
37.         }
    
38.         catch (InterruptedException ie) {}
    
39.       }
    
40. 
    
41.       public void paint(Graphics g) {
    
42.         Graphics2D g2 = (Graphics2D)g;
    
43.         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
    
44.             RenderingHints.VALUE_ANTIALIAS_ON);
    
45.         Shape s = createShape();
    
46.         g2.setPaint(paint);
    
47.         g2.fill(s);
    
48.         g2.setPaint(Color.WHITE);
    
49.         g2.draw(s);
    
50.       }
    
51. 
    
52.       private void timeStep() {
    
53.         Dimension d = getSize();
    
54.         if (d.width == 0 || d.height == 0) return;
    
55.         for (int i = 0; i < coordinates.length; i++) {
    
56.           coordinates[i] += deltas[i];
    
57.           int limit = (i % 2 == 0) ? d.width : d.height;
    
58.           if (coordinates[i] < 0) {
    
59.             coordinates[i] = 0;
    
60.             deltas[i] = -deltas[i];
    
61.           }
    
62.           else if (coordinates[i] > limit) {
    
63.             coordinates[i] = limit - 1;
    
64.             deltas[i] = -deltas[i];
    
65.           }
    
66.         }
    
67.       }
    
68. 
    
69.       private Shape createShape() {
    
70.         GeneralPath path = new GeneralPath();
    
71.         path.moveTo(coordinates[0], coordinates[1]);
    
72.         for (int i = 2; i < coordinates.length; i += 4)
    
73.           path.quadTo(coordinates[i], coordinates[i + 1],
    
74.               coordinates[i + 2], coordinates[i + 3]);
    
75.         path.closePath();
    
76.         return path;
    
77.       }
    
78. 
    
79.       public static void main(String[] args) {
    
80.         JFrame frame = new JFrame("Hypnosis");
    
81.         frame.add( new Hypnosis(4) );
    
82.         frame.setSize(300, 300);
    
83.         frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
    
84.         frame.setVisible(true);
    
85.       }
    
86.     }

复制代码

Creating an Image

Let’s take a look at producing some image data. A picture is worth a thousand words, and, fortunately, we can generate a pretty picture in significantly fewer than a thousand words of Java. If we just want to render image frames byte by byte, you can put together a BufferedImage pretty easily.

The following application, ColorPan, creates an image from an array of integers holding RGB pixel values:

   

1. //file: ColorPan.java
   
2.     import java.awt.*;
   
3.     import java.awt.image.*;
   
4.     import javax.swing.*;
   
5. 
   
6.     public class ColorPan extends JComponent {
   
7.       BufferedImage image;
   
8. 
   
9.       public void initialize() {
   
10.         int width = getSize().width;
    
11.         int height = getSize().height;
    
12.         int[] data = new int [width * height];
    
13.         int i = 0;
    
14.         for (int y = 0; y < height; y++) {
    
15.           int red = (y * 255) / (height - 1);
    
16.           for (int x = 0; x < width; x++) {
    
17.             int green = (x * 255) / (width - 1);
    
18.             int blue = 128;
    
19.             data[i++] = (red << 16) | (green << 8 ) | blue;
    
20.           }
    
21.         }
    
22.         image = new BufferedImage(width, height,
    
23.             BufferedImage.TYPE_INT_RGB);
    
24.         image.setRGB(0, 0, width, height, data, 0, width);
    
25.       }
    
26. 
    
27.       public void paint(Graphics g) {
    
28.         if (image == null)
    
29.             initialize();
    
30.         g.drawImage(image, 0, 0, this);
    
31.       }
    
32. 
    
33.       public void setBounds(int x, int y, int width, int height) {
    
34.         super.setBounds(x,y,width,height);  
    
35.         initialize();
    
36.       }
    
37. 
    
38.       public static void main(String[] args) {
    
39.         JFrame frame = new JFrame("ColorPan");
    
40.         frame.add(new ColorPan());
    
41.         frame.setSize(300, 300);
    
42.         frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
    
43.         frame.setVisible(true);
    
44.       }
    
45.     }

复制代码

Updating a BufferedImage

BufferedImage can also be used to update an image dynamically. Because the image’s data arrays are directly accessible, you can simply change the data and redraw the picture whenever you want. This is probably the easiest way to build your own low-level animation software. The following example simulates the static on an old black-and-white television screen. It generates successive frames of random black and white pixels and displays each frame when it is complete. Figure 21-5 shows one frame of random static.

1. Here’s the code:
   
2. 
   
3.     //file: StaticGenerator.java
   
4.     import java.awt.*;
   
5.     import java.awt.event.*;
   
6.     import java.awt.image.*;
   
7.     import java.util.Random;
   
8.     import javax.swing.*;
   
9. 
   
10.     public class StaticGenerator extends JComponent implements Runnable {
    
11.       byte[] data;
    
12.       BufferedImage image;
    
13.       Random random;
    
14. 
    
15.       public void initialize() {
    
16.         int w = getSize().width, h = getSize().height;
    
17.         int length = ((w + 7) * h) / 8;
    
18.         data = new byte[length];
    
19.         DataBuffer db = new DataBufferByte(data, length);
    
20.         WritableRaster wr = Raster.createPackedRaster(db, w, h, 1, null);
    
21.         ColorModel cm = new IndexColorModel(1, 2,
    
22.             new byte[] { (byte)0, (byte)255 },
    
23.             new byte[] { (byte)0, (byte)255 },
    
24.             new byte[] { (byte)0, (byte)255 });
    
25.         image = new BufferedImage(cm, wr, false, null);
    
26.         random = new Random();
    
27.       }
    
28. 
    
29.       public void run() {
    
30.         if ( random == null )
    
31.             initialize();
    
32.         while (true) {
    
33.           random.nextBytes(data);
    
34.           repaint();
    
35.           try { Thread.sleep(1000 / 24); }
    
36.           catch( InterruptedException e ) { /* die */ }
    
37.         }
    
38.       }
    
39. 
    
40.       public void paint(Graphics g) {
    
41.         if (image == null) initialize();
    
42.         g.drawImage(image, 0, 0, this);
    
43.       }
    
44. 
    
45.       public void setBounds(int x, int y, int width, int height) {
    
46.         super.setBounds(x,y,width,height);
    
47.         initialize();
    
48.       }
    
49. 
    
50.       public static void main(String[] args) {
    
51.         //RepaintManager.currentManager(null).setDoubleBufferingEnabled(false);
    
52.         JFrame frame = new JFrame("StaticGenerator");
    
53.         StaticGenerator staticGen = new StaticGenerator();
    
54.         frame.add( staticGen );
    
55.         frame.setSize(300, 300);
    
56.         frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
    
57.         frame.setVisible(true);
    
58.         new Thread( staticGen ).start();
    
59.       }
    
60.     }

复制代码

Filtering Image Data

An image filter is an object that performs transformations on image data. The Java 2D API supports image filtering through the BufferedImageOp interface. An image filter takes a BufferedImage as input (the source image) and performs some processing on the image data, producing another BufferedImage (the destination image).

1. Here’s the source code:
   
2. 
   
3.     //file: ImageProcessor.java
   
4.     import java.awt.*;
   
5.     import java.awt.event.*;
   
6.     import java.awt.geom.*;
   
7.     import java.awt.image.*;
   
8.     import javax.swing.*;
   
9. 
   
10.     public class ImageProcessor extends JComponent {
    
11.       private BufferedImage source, destination;
    
12.       private JComboBox options;
    
13. 
    
14.       public ImageProcessor( BufferedImage image ) {
    
15.         source = destination = image;
    
16.         setBackground(Color.white);
    
17.         setLayout(new BorderLayout());
    
18.         // create a panel to hold the combo box
    
19.         JPanel controls = new JPanel();
    
20.         // create the combo box with the names of the area operators
    
21.         options = new JComboBox(
    
22.           new String[] { "[source]", "brighten", "darken", "rotate", "scale" }
    
23.         );
    
24.         // perform some processing when the selection changes
    
25.         options.addItemListener(new ItemListener() {
    
26.           public void itemStateChanged(ItemEvent ie) {
    
27.             // retrieve the selection option from the combo box
    
28.             String option = (String)options.getSelectedItem();
    
29.             // process the image according to the selected option
    
30.             BufferedImageOp op = null;
    
31.             if (option.equals("[source]"))
    
32.               destination = source;
    
33.             else if (option.equals("brighten"))
    
34.               op = new RescaleOp(1.5f, 0, null);
    
35.             else if (option.equals("darken"))
    
36.               op = new RescaleOp(.5f, 0, null);
    
37.             else if (option.equals("rotate"))
    
38.               op = new AffineTransformOp(
    
39.                   AffineTransform.getRotateInstance(Math.PI / 6), null);
    
40.             else if (option.equals("scale"))
    
41.               op = new AffineTransformOp(
    
42.                   AffineTransform.getScaleInstance(.5, .5), null);
    
43.             if (op != null) destination = op.filter(source, null);
    
44.             repaint();
    
45.           }
    
46.         });
    
47.         controls.add(options);
    
48.         add(controls, BorderLayout.SOUTH);
    
49.       }
    
50. 
    
51.       public void paintComponent(Graphics g) {
    
52.         int imageWidth = destination.getWidth();
    
53.         int imageHeight = destination.getHeight();
    
54.         int width = getSize().width;
    
55.         int height = getSize().height;
    
56.         g.drawImage(destination,
    
57.             (width - imageWidth) / 2, (height - imageHeight) / 2, null);
    
58.       }
    
59. 
    
60.       public static void main(String[] args) {
    
61.         String filename = args[0];
    
62. 
    
63.         ImageIcon icon = new ImageIcon(filename);
    
64.         Image i = icon.getImage();
    
65. 
    
66.         // draw the Image into a BufferedImage
    
67.         int w = i.getWidth(null), h = i.getHeight(null);
    
68.         BufferedImage buffImage = new BufferedImage(w, h,
    
69.             BufferedImage.TYPE_INT_RGB);
    
70.         Graphics2D imageGraphics = buffImage.createGraphics();
    
71.         imageGraphics.drawImage(i, 0, 0, null);
    
72. 
    
73.         JFrame frame = new JFrame("ImageProcessor");
    
74.         frame.add(new ImageProcessor(buffImage));
    
75.         frame.setSize(buffImage.getWidth(), buffImage.getHeight());
    
76.         frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
    
77.         frame.setVisible(true);
    
78.       }
    
79.     }

复制代码

Using the AffineTransformOp Class

An affine transformation is a kind of 2D transformation that preserves parallel lines; this includes operations like scaling, rotating, and shearing. The java.awt.image.AffineTransformOp image operator geometrically transforms a source image to produce the destination image. To create an AffineTransformOp, specify the transformation you want in the form of an java.awt.geom.AffineTransform. TheImageProcessor application includes two examples of this operator, one for rotation and one for scaling. As before, the AffineTransformOp constructor accepts a set of hints; we’ll just pass null to keep things simple:

1.     else if (option.equals("rotate"))
   
2.       op = new AffineTransformOp(
   
3.           AffineTransform.getRotateInstance(Math.PI / 6), null);
   
4.     else if (option.equals("scale"))
   
5.       op = new AffineTransformOp(
   
6.           AffineTransform.getScaleInstance(.5, .5), null);

复制代码

In both cases, we obtain an AffineTransform by calling one of its static methods. In the first case, we get a rotational transformation by supplying an angle. This transformation is wrapped in anAffineTransformOp. This operator has the effect of rotating the source image around its origin to create the destination image. In the second case, a scaling transformation is wrapped in anAffineTransformOp. The two scaling values, .5 and .5, specify that the image should be reduced to half its original size in both the x and y axes.

When using an AffineTransformOp to scale images, it’s important to note two things. Scaling an image up will always result in poor quality. When scaling an image down, and more generally with any affine transform, you can choose between speed and quality. Using AffineTransformOp.TYPE_NEAREST_NEIGHBOR as the second argument in your AffineTransformOp constructor will give you speed. For the best quality use AffineTransformOp.TYPE_BICUBIC. AffineTransformOp.TYPE_BILINEAR balances speed and quality.

One interesting aspect of AffineTransformOp is that you may “lose” part of your image when it’s transformed. For example, when using the rotate image operator in the ImageProcessor application, the destination image will have clipped some of the original image out. Both the source and destination images have the same origin, so if any part of the image gets transformed into negative x or y space, it is lost. To work around this problem, you can structure your transformations such that the entire destination image is in positive coordinate space.