How many different ways can a great technical book stand out from the pack? That s the question you ll be able to answer in spades, once you ve gone through
Cameron McKenzie s, SCJA Certification Study Guide.
Everyone one that puts their hands on the SCJA Certification Guide from www.scja.com comments on two things right away: 1) how entertaining the book is, and 2) how easy it is to read.
I couldn t believe it! I read through the first three chapters in one sitting, and those three chapters made me want to read three more! Those are the types of comments we are flooded with when people finally get their hands on their SCJA Certification Guide.
And there are very good reasons as to why this Java book is so readable, and so enjoyable, not the least of which is the fact that the entire book was written, from start to finish, by one, and only one, author. The one-author-book is a rarity in the technical world these days, but its significance can t be understated. From start to finish, the author makes the objective of this book clear to get the reader certified,
fast. With one, single, focused, author penning the pages, this book reads like a single, clear and contiguous thought. The fragmentation seen in so many books written by multiple authors is nowhere to be seen in this logical and free-flowing certification guide.
But not only is the book entertaining and easy to read, but it approaches Java, and the whole issue of approaching Java certification, from an entirely new perspective. Most people penning a book on Java would start the book by discussing syntax and code. But Cameron McKenzie refuses to fall into that old trap, instead, turning the SCJA Exam objectives on their head, by starting off with an in depth discussion the big picture issues, getting the reader excited about Java, and
enthusiastic about learning how the language works.
Best selling author, Paul Sanghera, offers cohesive, concise, yet comprehensive coverage of all the topics included in the Sun Certified Programmer for Java 5 exam (CX 310-055). With a laser sharp focus on the exam objectives, the Study Guide goes beyond just being an "exam cram." The material is presented in a logical learning sequence: a section builds upon previous sections and a chapter on previous chapters. All concepts, simple and complex, are defined and explained when they appear the first time. There is no hopping from topic to topic and no technical jargon without explanation. No prior knowledge of Java programming is assumed. The single most difficult aspect of this exam is to read and understand the code in the exam questions in a limited amount of time. To help you get fluent and comfortable with the code, the book offers complete runnable code examples distributed over all the chapters and a codewalk quicklet feature at the end of each chapter.
Although the primary purpose of the book is to help you pass the SCJP exam, it will also serve as a good reference after the exam.
- Hundreds of questions modeled after the real exam with fully explained answers.
- A complete practice exam with questions modeled after the real exam and fully explained answers.
- Hundreds of complete runnable code examples, explained in the book, that you can download and experiment with. This is a code-intensive exam.
- The Codewalk Quicklet feature based on the process-based codewalk philosophy to prepare you for efficient response to the code-based questions in the exam.
- The Exam Quick Prep feature which recaps all the important points for the last hour of preparation before taking the exam.
- Useful information and analysis for the programmers who are considering updating the J2SE 1.4 certification to J2SE 5.
Customer Reviews:
Very good book.......2007-07-25
In the beginning of the year, Java equals "null" to me ( I know C/C++). I decided to learn the language and take the SCJP as a measure of my learning. I tried the Deitel book but didn't like it. Then I started to read the Kathy Sierra book, but they assume you know the basics (not my case). Due to the comments of one of the reviewers, I bought this book and liked it very much. I read it twice, tried all examples, fragments and tests and then went back to the Sierra book, which is more comprehensive (it is a much bigger book), has better explanations of generics and threads and has more tricky questions. I was able to pass the SCJP exam this month thanks to these two very good books.
I do not give 5 stars due to the presence of several typos and some other minor errors in the text. These errata are not yet in the book site, but as you are studying for the exam, you will spot then when you compile or cross-check with the SUN Java documentation. But these are a small nuisance considering the overall value of the book.
Helpful Starting Point.......2007-07-12
This was the only book I bought and I passed the cert. I found the book to be generally good. I felt a couple of the examples were poor. For instance on page 141 the finding the area of different shapes, a classic example of where one should use polymorphism, the book provides an example of overloading operators. Yes, in the sense the code is "correct" but I find the misuse to be confusing. There are a number of items including some questions in the review exam that are just wrong. That is if you type the code in and run it you don't get what the book claims that you should. These do not seem numerous and I have not found any certification material that is without this sort of problem. The reality of preparing for the test is that if someones answer doesn't make sense you have to test it for yourself. It would be nice if publishers would hire someone to go cut and paste all of the code into a compiler and find this stuff.
More importantly there is not enough material on generics and there is only ONE practice exam.
Having complained I should and that the text is readable and helpful in preparing for the cert. I found it to be a good starting point for my preparations.
The Best SCJP Study Guide and Java 5 Book to Learn Java.......2007-04-23
I have just passed the SCJP for J2SE 5 exam largely after preparing from this book. However, to be on the safe side it might be good idea to consider using more than one resource to prepare for this exam, because the exam is certainly not a walk in the park. I have read all the three SCJP for Java 5 study guides from cover to cover. So I would like to share my experience with these study guides in the context of both the exam and learning Java:
"SCJP Exam for J2SE 5" (this book) by Paul Sanghera.
I found this Study Guide the best among all, especially for the beginners. As another reviewer said the author has the unique approach of saying only what is necessary. He also has the skill of making difficult concepts easy to understand without compromising accuracy. The material is organized in such a manner that we also learn Java while preparing for the Exam. Because everything is explained from scratch, and there is no hopping from topic to topic, this book is especially suitable for the beginners. Here are some features in the book that I especially liked:
* All concepts are clearly defined and explained by using visuals where necessary. It makes this book self-contained.
*Tons of code examples explained in the book, which I downloaded from the book website and experimented with them to build confidence.
* The Exam Quick Prep appendix. I went through this just before the exam to refresh all the important points quickly.
* Exam's Eye View, Caution, and Notes throughout all chapters, which re-enforced important points.
* An appendix that provides useful information and analysis for those who are considering updating the J2SE 1.4 certification to J2SE 5.
If you are a beginner, this is your book. If you are an advanced Java programmer, this book will still take you through the exam without boring you.
Bottom line: I agree with another reviewer that books like these are hard to find.
"SCJP for Java 5" by Kathy Sierra and Bert Bates.
This is a good book for advanced Java programmers, but rather over-hyped. If you are planning to buy two books to prepare for the SCJP exam, this is the second book I will recommend. However, this is NOT the book for the beginners. If you do not have intensive Java programming experience, do not use this book as your first book. If you want to use this book, first study Sanghera's book.
"Complete Java 2 Certification" by Phil Heller and Simon Roberts.
If you want to buy three SCJP for Java 5 study guides, this is the third one I will recommend. It does not do justice with some of the exam objectives. Overall exam coverage is not that great, but you will learn some Java topics.
Get Up to Speed in Java in Preparation for the SCJP1.5 Exam!.......2007-04-16
This certification study-resource from Author: Paul Sanghera is a great tool for quickly getting up to speed in java with a view to taking the java programmer exam! As someone who recently succeeded at the SCJP 1.5 exam, i can vouch for this book. The following review is thus for those interested in preparing for the exam and not quite sure whether this book is the right tool for the job.
As a green-horn in Java, I found the following 2 exam-study resources very useful in learning how to program in java, and taking the Sun Certified Java Programmer for J2SE5 certification:
(Book 1.) SCJP Exam for J2SE 5. - (SCJP E5)
(Book 2.) SCJP Study Guide. - (SCJP SG)
Note: (due to review real-estate constraints, i shall limit this review to (Book 1) ie: [SCJP E5 (Sanghera)] -( the current book in question). you'll find a (Book 2) review on the customer review page for : SCJP SG
Like most new-comers to java, I wanted to get-up to speed in java rather quickly. Therefore, the (SCJP E5) book from Sanghera was chosen as the first reading-reference, as it seemed concise, compact & condensed. However, if i had to do things-over, and choose which one book to use in order to scale the SCJP 1.5 exam -(whilst learning the Java language as well), I'd pick the [SCJP SG] from Sierra & Bates.
Here's why...
About the (SCJP E5) book : this book is great for beginners. i found that it brought me up to speed quickly Re: java, as well as preparing for the exam. However, unless you have previous knowledge & experience coding in java, you might need another book for deeper clarity and more rigor regarding 5 SCJP1.5 exam-objective related areas, viz:
(1.) - Generics
(2.) - Threading
(3.) - I/O + Regular Expressions + Parsing
(4.) - Packages + Jar Files & Static Imports
(5.) - Exceptions
Note that: while the 5 exam-objectives above are quite well treated in the (SCJP E5) Sanghera book, I found that the (SCJP SG) Sierra & Bates book, provided the finer level of details that i believe a beginner might further require in order to have a better grasp Re: these 5 exam-objectives cited above (AND) (the questions in the real exam do require this further finesse with those details).
Otherwise, with the material in this book alone and without any hands-on experience, i reckon, a beginner might struggle a bit to pass the real exam by a comfortable margin.
and this is why i cant give the book alone all 5 points of credit. (I would however award 4.5 points!)
Upon completing the book, any access to good exam-revision practise material would be very useful in order to pass at the exam-level. while the (SCJP E5) book features useful questions and answers at the end of every chapter, as well as a further round of 73 questions in Appendix-D of the book; I believe people preparing for the exam would find it useful to seek out further resources for exam-question practise & revision purposes .
As review-space is short, i shall include below only 2 of the exam-revision resources which really helped prepare for the actual exam (for details Re: The other key resource used, u might want to refer to the customer review posting for (Book 1): SCJP SG
u might want to check these out:
(1.) "Tiger notes" on JavaRanch. look under the SCJP FAQ section for : [Mikalai Zaikin's SCJP Tiger notes ]. You can get a paperback copy of notes similar to these on Amazon if you prefer. lookup: Java 1.5 Tiger. However, i'd advise that you use it only as a prep-extra, just to cross-check certain topical-details you may need to clarify ie: (java: "Exceptions"). I wouldn't recommend it as your sole & unique study guide.[ kittybooboo's notes ] on JavaRanch are also quite good.
(2.) Turn to a SCJP Group for advice on the forums. They represent people in the same boat as those trying to prepare for and pass the SCJP exam. here are 2 such groups you can join.(Yahoogroups): Google: [" tech groups yahoo + scjp5" ]; (Another is): Google:[ "jchq + net" ] (-OR-) if you are preparing for the SCJP 1.4:( scjp 1.4 groups ) : Google:[ "uk groups yahoo + java_balk" ] ps: a good book for SCJP 1.4 is :A Programmer's Guide to Java Cert
(3:) refer to my customer review posting for (Book 1) ie: SCJP Study Guide
Schedule, Sit and Ace the exam in 2hrs:55mins, when you've finished with these various exam-practise questions and study-guides.
The exam is comprised of 72 questions of which several are fashioned as drag & drop coding-scenario questions. Although, the pass mark is 59%, I think most people -(myself included!), view the exam as tough, because of its code intensive nature. I think reading, tackling & spotting possible coding errors in code-samples 6-30 lines long is tough under such time-constrained exam conditions, Plus, No credit is given for partial answers. However, on the up-side, it is do-able with the appropriate revision preparation regime.
Curiously, in comparison, the previous SCJP exam ie: the SCJP 1.4 exam, is comprised of 61 questions , for which one has 2hrs to complete. Plus, the pass mark is 52%. That exam, is generally deemed to be an easier exam compared with the SCJP 1.5 exam; at least so attests certain in the user-community on JavaRanch.
for those wondering, i took the SCJP 1.5 exam on March 19th 2007. the passing-score achieved was: 98% ie: (71 out of 72 questions ). The pass-mark is 59%.
Good Luck!
next stops: SCBCD, SCWCD, SCEA, SCJWSD.
Cheers :-)
Great Book.......2007-04-08
Passed the exam on the first try after primarily preparing from this book. Very well organized...I learned Java while preparing for the exam...The exam is of course not a walk in the park...However, this book helped...Concise, to the point, and perfect flow...There are actually much fewer typos in this book than in the other SCJP exam book that I have...I love the author's style...he has a way of making difficult concepts easy to understand, and yet stay accurate... Will get you through the exam...but also good to just learn Java.
Average customer rating:
- Worked for me!
- I look it very interesting, but i don't see anything
- Maybe the next edition will be usable?
- Good book tarnished by errors
- It does the job, well.
|
Sun Certified Programmer for Java 2 Study Guide (Exam 310-025)
Inc Syngress Media
Manufacturer: Osborne/McGraw-Hill
ProductGroup: Book
Binding: Hardcover
 Java
| Exams
| Certification Central
| Computers & Internet
| Subjects
| Books
Osborne-McGraw-Hill
| Publisher
| Certification Central
| Computers & Internet
| Subjects
| Books
Java
| Certification Central
| Computers & Internet
| Subjects
| Books
General
| Certification Central
| Computers & Internet
| Subjects
| Books
Sun Professional Certifications
| Certification Central
| Computers & Internet
| Subjects
| Books
General
| Java
| Programming
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
General
| Languages & Tools
| Programming
| Computers & Internet
| Subjects
| Books
General
| Computers & Internet
| Subjects
| Books
General
| Software
| Computers & Internet
| Subjects
| Books
Mathematics
| Professional Science
| Professional & Technical
| Subjects
| Books
| Applied
| Chaos & Systems
| Geometry & Topology
| Mathematical Analysis
| Mathematical Physics
| Number Systems
| Pure Mathematics
| Transformations
| Trigonometry
Look Inside Computer Books
| Trip
| Specialty Stores
| Books
Similar Items:
-
SCJP Sun Certified Programmer for Java 5 Study Guide (Exam 310-055) (Certification Press Study Guides)
-
Head First Servlets and JSP: Passing the Sun Certified Web Component Developer Exam (SCWCD)
-
Head First Java, 2nd Edition
ASIN: 0072132086 |
Amazon.com
Anyone preparing for Sun's certification exam 310-025 will find Sun Certified Programmer for Java 2 Study Guide of use. It provides a fast-paced tour of essential Java features and do-it-yourself sample test questions that will improve your chances for success on the exam.
This fact-based approach highlights material that will be on the test. This means that it pays special attention to certain topics (for example, public-, protected-, and private-access rules), even though you may not normally need to think at this level of detail. Besides the basics, the text explains the details of class design and string processing particularly well. Exception handling and garbage collection in Java is also discussed, as well as class design as it pertains to the certification test. The book includes plenty of tricks and tips for what's covered on the test, along with what to watch out for in certain areas.
A longer chapter on AWT for building basic user interfaces in Java rounds out this text. Every section provides challenging sample questions (usually about 20 for each chapter), which let you test your knowledge. An appendix contains more than 100 pages of answers and explanations for these self-test questions. (The companion CD-ROM features a computer-based test, similar in format to the actual certification exam.) If you have some Java experience, this book will quickly help ready you for official Java certification. Sun Certified Programmer for Java 2 Study Guide definitely delivers the goods. --Richard Dragan
Topics covered:
- Test-preparation guide to the Sun Certified Programmer for Java 2 exam 310-025
- The format of the certification test
- Java language basics
- Data types, arrays, and strings
- Declarations and access control
- Operators
- Equality testing
- Flow control
- Exception handling (try, catch, and finally blocks)
- Checked and unchecked exceptions
- Java garbage collection
|
- Mark-sweep algorithms
- Encapsulation and class design in Java
- Overloading and overriding methods
- Inner classes
- Threads and synchronization techniques
- Math, String, and StringBuffer classes
- Java collections
- The AWT user interface classes
- Event handling (events, sources, and listeners)
- Sample test questions and answers
| |
Book Description
The only classroom-based training and self-assessment system! Osborne's Sun Certified for Java 2 Study Guide provides 100% complete coverage of all official exam objectives for this challenging exam. Based on 200,000+ hours of IT training experience, the book contains hundreds of practice exam questions and hands-on exercises. The CD-ROM features full CertTrainer CBT software with interactive tutorials and lab simulations, plus the new ExamSim adaptive test engine.
Customer Reviews:
Worked for me!.......2002-12-18
I started with the first Stanek edition which had too many errors and weak treatment of some important subjects. I found this book at a Java conference. I found it to be well organized, well written and learned a lot from it. There were a few errors and some an annoying inconsistency in the discussion of threads but nothing of any significant consequence -- I passed the exam easily on the first try. One of the things I like most was that the more challenging self test questions were more difficult than those I had encountered on the exam. Most of the questions in the self tests were very close to what I saw in the exam. The part I like least was the CD. It had most of the same questions as the book. After the first two chapters I gave up the CD and went back plain old pencil and paper. The reason I gave it four stars is that the book isn't perfect and I didn't really benefit from the CD.
I look it very interesting, but i don't see anything.......2002-10-23
I not yet see this book, because i haven't read it
Maybe the next edition will be usable?.......2002-10-04
This book seems to have been rushed into production; it desperately needs a revised second printing. As it stands, however, there are just too many errors and misstatements for it to be taken seriously. Also, the topics are somewhat out of line with the questions on the exam.
Finally, a tough blow for people who are studying hard for the Sun Certified Java Programmer exam: in nearly every one of the practice tests at the ends of the book's chapters, one or more of the book's suggested answers to their own test questions are simply wrong, wrong, wrong. If this book's practice exams give you high marks, you probably will not do very well on the actual exam.
If I hadn't switched over to the Sybex book, I probably would have failed the exam, but I passed it the first time. However, it cost me a week or so of finding and unlearning all the misinformation that I had already absorbed. So I recommend avoiding that.
Good book tarnished by errors.......2002-09-15
What I like about the book:
- Writing style, easy to follow, good examples
- End of chapter summaries (a few diagrams would help)
- End of chapter exam with answers (good measure of progress)
- Simulated exam (although I would like more that than just one test)
What I did not like about the book
- Errors in text of book, - way to many of them
- Errors in end of chapter exams, - again way to many
- Errors in simulated exam (had the least errors once the update was applied)
If the publisher could fix the errors, this would be a great book. Web site has an update for the simulated exam (still had errors), but I could not find anything for the text or end of chapter exams. Accuracy is a must when you are buying a book to study to pass a java certification exam.
Update: took the Sun Certified Programmer for Java 2 Platform 1.4 Examination on Oct 3rd, 2002 and passed.
It does the job, well........2002-09-13
I had ONE goal - to pass the certification exam. I had ONE book to study from - this book. And it did the job. It covered all the objectives for the exam. The questions at the end of chapters are a good shakedown to highlight your weaknesses.
If you can notice each and every little typo, that's a compliment to the book, it has prepared you well enough to notice the right from wrong. All you need to pass this exam is: this book + mock exams (beyond what's available on the CD).
Customer Reviews:
Excellent for SCJP Exam (even SCJP 5).......2007-01-16
This is a great book to prepare for the SCJP exams. The pity is that it was designed for SCJP 1.4. But where the subject matter for SCJP 5 is the same as for SCJP 1.4 I find this book better than the Sierra/Bates book. The discussion is very complete and thorough. Very good discussion of nested classes, threads, etc. But you need the S/B book for generics and the newer stuff.
A good book to pass SCJA 4.0 -- but it takes time to teach me things not required by the SCJA 4 exam.......2006-12-02
This is a quality book, the only thing that I've found wrong with it is that it teaches Java 4.0 and I want to learn Java 5.0 now. Also, at the beginning of each chapter the book identifies what is required by the Exam and what the authors have added to the book. In the "heat-of-the-battle", as you're studying the book, the exam objectives and the extraneous material are mixed together. I have enough to do to certify in SCJA, SCJP, SCJD, and SCBCD without learning any extras. If the authors think that they know better than Sun as to what I should learn, they should clearly mark it, or have a part I that is essential to pass the exam and a part II that is additional learning that the authors want me to learn.
This book show me my lackings.......2006-11-04
But it is not good for explain themes(eg. reference types o arrays). You must to consult other books for more complete explanations. But this book is very necesary like guide to you must to known. It is essential.
Good but obselete.......2006-08-26
The concepts in the book are well explained and i think its a good book for a beginner programmer but obsolete for sun java certification 1.5.
very deep... great for hardcore java programmer .......2006-06-02
i buy this book together with kathy's book and have passed the exam with 95% score. i found the exam very easy (although i still missed 3 of the 61 questions), i guess it's because i have read this whole book thoroughly. kathy's book is very good too but just covers what you really need to pass the exam. this book goes a step further by explaining each concept thoroughly, more than you need to pass the exam. if you want to have deep knowledge of how java works, and not just merely to pass the exam, then this is the best book for you.
Book Description
Sun Microsystems' Sun Certified Programmer exam (Sun CJPE) allows programmers to validate their valuable Java programming skills and provides the IT industry wth a standard to use when recruiting professional. A Programmer's Guide to JavaTM Certification prepares readers for the CJPE by teaching them sound Java programming skills and covering the core language and all the major APIs. Requiring minimal Java experience, a Programmer's Guide to JavaTM Certification is the surest way to accomplish the exam. In addition, it is a comprehensive primer providing coverage of additional topics that every Java programmer should master to be proficient in this field.
Customer Reviews:
Excellent Resource!.......2005-12-21
Reading and understanding the content of this book, and the one written by 'Sierra and Bates', are the major contributing factors in getting me a 91% passing grade on the first attempt!
Passed SCJP the first attempt........2005-11-08
This is an excellent study resource and I would recommend it to anyone pursuing their java programmer certification. Be sure to suppliment this book with plenty of practice tests and you should do fine on the exam. Good Luck!
The BEST book on non-j2ee java........2003-07-19
I have read over a dozen books on the java and this by far the best one for learning the language in its entirety. Obviously, this book can't cover everything but it gives a very thorough and in-depth introduction. If you can only have one book on java 2, make this the one you pick. Many other books on the subject waste tons of space with simple examples that aren't very informative. This book cuts through the nonsense and gives you all it can in its 700 pages. Great explanations, Great Code Samples, all around top notch.
Really Helpful for certification.......2003-06-28
I found this book to be a very useful resource for the Certification. The questions and mock exam were closer in quality and difficulty to the actual exam compared to other mock exams. I found quite a few other mock exams on the web to be misleading about how difficult the exam would be and also about what type of questions would be asked.
Good book for Certification and a little more.......2003-06-25
I bought this book in addition to another Java cert book (The Complete Java 2 Certification Study Guide). While the other book was like a Java Cert for dummies and was straight to the point (gave u just what u need and nothing more), this book was more like a java textbook geared around certification. It had alot more indepth info than was needed for the exam. If your a true java nerd and you enjoy reading textbook type books, this is your certification book. If your someone in a hurry and just wanna pass the exam with a superfical knowledge of exam material, then some of the other books might be a better option.
Overall, Good book. Gave info needed to pass the exam, and will be kept on the bookshelf nearby now that exam is over.
Amazon.com
Written for the experienced Java developer, The Java Native Interface documents the latest in native code programming for the Java platform using the Java Native Interface (JNI) with C/C++. Author Sheng Liang built the book around "dos and don'ts," even specifying within the introduction when you should and when you should not use JNI. Though sometimes densely written, this title certainly conveys a good deal of technical information on using native code with Java.
After a simple JNI "Hello World" code example, this book explores multiple aspects of the JNI API, starting with the use of Java strings and arrays within native code. Liang follows by transitioning into calling Java members and methods in C/C++. Here the author presents caching strategies for improving the performance of native code that interacts with or executes Java programs, including a discussion of local and global references that incorporates global weak references in Java 2.
The book also looks at handling exceptions within C/C++ code, as well as tips for working with Java threads. The author shows how to simplify access to C/C++ code through shared stubs and how to use peer classes to encapsulate native code from within Java. A section on common traps and pitfalls lists some common pitfalls to avoid when working with the JNI. After presenting the JNI specification, the author provides the most immediately useful text in the book--over 100 pages of reference material listing JNI data types and methods.
As a reference and programming guide, The Java Native Interface provides concise and timely technical details on getting Java and C/C++ code to coexist within your projects. --Richard Dragan
Customer Reviews:
Good book but do not buy it. It is available FREE from SUN........2003-04-26
The reason I write this comment is that I was suprised
that this book is available in electronic form, free
of charge from Sun website.
As far as I read the book, it is quite good but I did not
test anything. I probably will in my summer project and I will
inform you if what the Native Interface promised , did
finally work.
Anyway the Sun website for the book is :
[website]
Programmer.......2002-07-21
This is one of the best Java programming books around. Not only are all the major issues surrounding JNI programming addressed, but the author also presents a great disussion on the organization of JNI.
My only complaint is that embedding JNI in native apps is barely touched. However, this is a complicated subject, and the information shared is enough to get started.
This book is definitely required reading for those interested in bringing legacy code into a Java framework. Also, its a good read, and a great example of nonfiction writing.
Dont Buy this Book It is Freely Available on the Java Site.......2002-04-02
This is book is very handy if you are programming for JNI. I went and bought this book but later found that is free on the Sun's Java site.... So buy it only if you need a paper copy. If you are ok with a PDF or html copy goto sun's website to get it.
Not enough examples........2002-03-29
I have a feeling Sun Micro had more to do with why there's not enough examples of how to do advanced features of JNI. Afterall, using JNI essentially breaks the philosophy of compile once, run everywhere. Some simple, so you think, things like moving a string array from Native-C to Java is not described at all. Nor is moving a float array from Native-C to Java. What this book does well is describe for the beginner how to get started with simple examples. Essentially to learn the core JNI concepts. But after that, trying to apply the more advanced JNI functions and classes, there's really no ample examples. You have to rely on the Newsgroups essentially. Forget about java.sun.com, they don't go that deep into it either. Good book but be aware of its limitations.
Where's the rest of the book?.......2002-03-05
While I have enjoyed many of Sun's books, this one is simply inadequate. The organization of topics was mediocre, but, in my opinion, the book is a disappointment because of its sheer lack of depth (just 300 pages). What few examples that were provided are typically discussed in two or three sentence paragraphs, often leaving out several key concepts contained in the example. In addition, many more subtle patterns/topics seem to be left as an excerise for the reader. Unfortunately, this probably _is_ the most complete JNI book to date.
Average customer rating:
- Great coverage of numerical computing in Java
- Nice Book
- Excellent coverage of many aspects in numerical computing
- if (java != eCommerce) { ...
- Educational, interesting, and fun
|
Java Number Cruncher: The Java Programmer's Guide to Numerical Computing
Ronald Mak , and
Ron Mak
Manufacturer: Prentice Hall PTR
ProductGroup: Book
Binding: Paperback
General
| Java
| Programming
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
General
| Languages & Tools
| Programming
| Computers & Internet
| Subjects
| Books
Computer Mathematics
| Artificial Intelligence
| Computer Science
| Computers & Internet
| Subjects
| Books
General
| Computers & Internet
| Subjects
| Books
General
| Software
| Computers & Internet
| Subjects
| Books
Mathematics
| Professional Science
| Professional & Technical
| Subjects
| Books
| Applied
| Chaos & Systems
| Geometry & Topology
| Mathematical Analysis
| Mathematical Physics
| Number Systems
| Pure Mathematics
| Transformations
| Trigonometry
Look Inside Computer Books
| Trip
| Specialty Stores
| Books
All Titles
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Computers & Internet
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Professional
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Similar Items:
-
A Numerical Library in Java for Scientists and Engineers
-
Object-Oriented Implementation of Numerical Methods: An Introduction with Java & Smalltalk (The Morgan Kaufmann Series in Software Engineering and Programming)
-
Bundle of Algorithms in Java, Third Edition (Parts 1-5): Fundamentals, Data Structures, Sorting, Searching, and Graph Algorithms, Third Edition
-
JavaTech, an Introduction to Scientific and Technical Computing with Java
-
Technical Java: Applications for Science and Engineering
ASIN: 0130460419 |
Customer Reviews:
Great coverage of numerical computing in Java.......2007-01-04
This book is an introduction to numerical computing that is both comprehensive and fun. It is not a textbook on numerical methods or numerical analysis, although it shows many key numerical algorithms all coded up in Java. The book examines these algorithms enough that you get a feel for how they work and why they're useful, without formally proving why they work. There are also demonstrations of many of the algorithms with interactive graphical programs. Overall I enjoyed this book a great deal. It is not a beginner's book on Java - you should be a pretty good Java programmer already. Also, you should be at least somewhat mathematically mature for the material past part one. That is, you should have had some Calculus and some Linear Algebra prior to reading the last 3 of the 4 parts of this book. I further describe this book in the context of its table of contents.
Part 1: WHY GOOD COMPUTATIONS GO BAD - Simply copying formulas out of a math or statistics textbook to plug into a program will almost certainly lead to wrong results. The first part of this book covers the pitfalls of basic numerical computation.
Chapter 1 discusses floating-point numbers in general and how they're different from the real numbers of mathematics. Not understanding these differences, such as the occurrence of roundoff errors, and not obeying some basic laws of algebra can lead to computations that go bad.
Chapter 2 looks at the seemingly benign integer types. They don't behave entirely as the whole numbers of mathematics do. Arithmetic operations such as addition, subtraction, and multiplication take place not on a number line, but on a clock face.
Chapter 3 examines how Java implements its floating-point types. The chapter examines the IEEE 754 floating-point standard and shows how well Java meets its provisions.
Part 2: ITERATIVE COMPUTATIONS - Computers are certainly good at looping, and many computations are iterative. But loops are where errors can build up and overwhelm the chance for any meaningful results.
Chapter 4 shows that even seemingly innocuous operations, such as summing a list of numbers, can cause trouble. Examples show how running floating-point sums can gradually lose precision and offer some ways to prevent this from happening.
Chapter 5 is about finding the roots of an algebraic equation, which is another way of saying, "Solve for x." It introduces several iterative algorithms that converge upon solutions: bisection, regula falsi, improved regula falsi, secant, Newton's, and fixed-point. This chapter also discusses how to decide which algorithm is appropriate.
Chapter 6 poses the question, Given a set of points in a plane, can you construct a smooth curve that passes through all the points, or how about a straight line that passes the closest to all the points? This chapter presents algorithms for polynomial interpolation and linear regression.
Chapter 7 tackles some integration problems from freshman calculus, but it solves them numerically. It introduces two basic algorithms, the trapezoidal algorithm and Simpson's algorithm.
Chapter 8 is about solving differential equations numerically. It covers several popular algorithms, Euler's, predictor-corrector, and Runge-Kutta.
Part 3: A MATRIX PACKAGE - This part of the book incrementally develops a practical matrix package. You can then import the classes of this package into any Java application that uses matrices.
Chapter 9 develops the matrix class for the basic operations of addition, subtraction, and multiplication. It also covers subclasses for vectors and square matrices. The chapter's interactive demo uses graphic transformation matrices to animate a three-dimensional wire-frame cube.
Chapter 10 first reviews the manual procedure you learned in high school to solve systems of linear equations. It then introduces LU decomposition to solve linear systems using matrices. An interactive demo creates polynomial regression functions of any order from 1 through 9, which requires solving a system of "normal" equations.
Chapter 11 uses LU decomposition to compute the inverse of a matrix efficiently and reliably. A demo program tests how well you can invert the dreaded Hilbert matrices, which are notoriously difficult to invert accurately. The chapter also computes determinants and condition numbers of matrices, and it compares different algorithms for solving linear systems.
Part 4: THE JOYS OF COMPUTATION - The final part of this book covers its lighter side of numerical computation.
Chapter 12 covers Java's BigNumber and BigDecimal classes, which support "arbitrary precision" arithmetic--subject to memory constraints, you can have numbers with as many digits as you like. This chapter explores how these classes can be useful. You compute a large prime number with more than 3,000 digits, and you write functions that can compute values such as the square root of two and e^x to an arbitrary number of digits of precision.
Mathematicians over the centuries have created formulas for computing the value of pi. Enigmatic Indian mathematician Ramanujan devised several very ingenious ones in the early 20th century. An iterative algorithm supposedly can compute more than 2 billion decimal digits of pi. Chapter 13 uses the big number functions from Chapter 12 to test some of these formulas and algorithms.
Chapter 14 is about random number generation. A well-known algorithm generates uniformly distributed random values. It examine algorithms that generate random normally distributed and exponentially distributed random values. The chapter concludes with a Monte Carlo algorithm that uses random numbers to compute the value of pi.
Mathematicians have mulled over prime numbers since nearly prehistoric times. Chapter 15 explores primality testing and investigates formulas that generate prime numbers, and it looks for patterns in the distribution of prime numbers.
Chapter 16 introduces fractals, which are beautiful and intricate shapes that are recursively defined. There are various algorithms for generating different types of fractals, such as Julia sets and the Mandelbrot set. In fact, Newton's algorithm for finding roots, when applied to the complex plane, can generate a fractal.
Nice Book.......2006-11-10
The book doesn't teach you Java. It is assumed that you already know Java.
doesn't cover all of Numerical calculus and not all of mathematical proofs but great if you are looking study practical programming with Java.
I recommend this book only if you know Java and have basic numerical knowledge.
Excellent coverage of many aspects in numerical computing.......2005-10-21
I have got hold of this book just recently. This is an excellent book on numerical computing using Java that covers many important aspects in numerical computing. I have been writing numerical methods in Java back in graduate school as well as in my professional career for mission critical programs. I must say this book has addressed many issues that must be taken into account such as machine epsilon, choices of numerical methods for different problems, limitations and precautions in using different data types, etc in Java in which if taken for granted, would produce disastrous results.
Ronald Mak has taken the trouble to explain IEEE floating point standards in a fun and easy-to-understand manner.
Another thing about this book that is worthy of a mention is its great OO programming styles. Codes are also well commented and reader friendly. Overall, it is a great source to learn not just on how to program numerical methods in Java but how to write good OO programs.
The only two bad things I could say about this book is that I should have gotten of this book much earlier and if only Amazon allows a Six Stars rating.
if (java != eCommerce) { ..........2004-11-22
As the author says, last time I looked Java still had the +, -, /, * and % mathematical operators.. though most programmers end up forgetting it lost as they are in the boring, vulgar and repetitive coding of boiler-plate "enterprise" (read "sell sell sell") applications. This book does a very good job of introducing a Java programmer to one of the most fun and interesting powers that Java can offer ... that is playing with numbers and exploring the world of mathematics. Forget (at least for a little while) Servlets, JSP, EJB, and database massaging... and give a look to how you can use your JDK to study functions, solve differential equations, integrals, system of equations, discover prime numbers and admire the beauty of fractals. The treatment of the various subjects is done is sufficient detail to be clear and sound, but without burderdening the reader
with detail and depth best left for more specialized and hard-core texts that the curious reader can explore after this one. Refreshing.
Educational, interesting, and fun.......2003-05-26
At one time or another, most of us will likely have to write code performing some amount of numerical computation beyond simple integer arithmetic. As many of us are neither mathematicians nor intimately familiar with the bit gymnastics our machines must perform in order to manipulate numbers, we can get ourselves into trouble if we're not careful. Luckily, "Java Number Cruncher" comes to the rescue.
This book is an introduction to numerical computing using Java providing "non-theoretical explanations of practical numerical algorithms." While this sounds like heady stuff, freshman level calculus should be sufficient to get the most out of this text.
The first three chapters are amazingly useful, and worth the price of admission alone. Mak does a fine job explaining in simple terms the pitfalls of even routine integer and floating-point calculations, and how to mitigate these problems. Along the way the reader learns the details of how Java represents numbers and why good math goes bad. The remainder of the book covers iterative computations, matrix operations, and several "fun" topics, including fractals and random number generation.
The author conveys his excitement for the subject in an easy-to-read, easy-to-understand manner. Examples in Java clearly demonstrate the topics covered. Some may not like that the complete source is in-line with the text, but this is subjective. Overall, I found this book educational, interesting, and quite enjoyable to read.
Amazon.com
Newly revised and updated for Java 2 standards, the second edition of The Complete Java 2 Certification Study Guide is packed with information on what you'll need to know to pass both the Sun Java Programmer and Developer Exams. With Java certification becoming ever more popular, this title is an essential resource for anyone who's preparing for it.
The cover of the book asserts that one of its team authors actually contributes questions to Sun's tests.
The goal here isn't so much to beat the testmakers (although the book has plenty to say about test-taking strategy) as it is to master the finer points of Java that you'll need to understand to succeed on the exam. The focus is on the areas that Sun has defined as important. The Programmer Exam--the first level of Sun certification--is covered first. Basic language features are reviewed, such as access specifiers, operators, and other keywords that will help make you an expert. (Some sections explain with great clarity the mysteries of Java's "extra" shift operator and other features.) Other chapters cover threads and multithreading strategies, as well as user-interface design with layout managers (which Sun considers important).
The second half of the volume concentrates on the Developer Exam, a more free-form exercise in which programmers write custom code, based on a specification from Sun. Two case studies, one for a room-scheduling application and another for a trouble-ticket system that tracks requests for technical support, illustrate this test. As the solution is presented, you'll learn how to build custom client/server software, and how to use Remote Method Invocation (RMI) and other advanced techniques. There's also advice for the best programming styles and choices for passing this challenging exam.
As in the previous edition, each chapter in this book concludes with sample questions (about 10 each) to help you study. In the new edition, there's now a full sample Programmer Exam (both printed and on the accompanying CD-ROM), which simulates the length and format of the real thing. In all, the new edition of this previously bestselling title will continue to provide helpful preparation for anyone who seeks Sun certification.
Despite the bulk (over 900 pages), this book actually makes for quick reading, and will help anyone decipher some of the more difficult aspects of the Java programming language. --Richard Dragan
Topics covered:
- Introduction to Sun certification and the Programmer Exam
- Java language fundamentals: primitive data types, literals, arrays, and garbage collection
- Java operators up close (including evaluation order and the shift operators)
- Access specifiers (public, private, default, and protected)
- Converting and casting rules in Java (including promotions)
- Flow-control statements
- Exception handling
- Object-oriented design primer
- Overloading and overriding
- Inheritance and subclassing
- Inner classes
- Threads and synchronization techniques
- Using the Math, String, and StringBuffer classes effectively
- The Java 2 Collections API
- Layout managers
- Event handling
- AWT components
- Painting
- File I/O
- Introduction to the Sun Developer Exam
- Sample room-reservation case study
- Working with Java databases
- Creating a client/server system from scratch
- Remote Method Invocation (RMI)
- Multithreading issues
- User-interface design with Swing
- Trouble-ticket problem tracker case study
- Using Swing JTable, JTree, and other Swing controls
- How to submit finished exam work to Sun
- Tips for the follow-up exam
- Sample Programmer Exam (including CD-ROM version)
- The future of Sun certification
Book Description
Welcome to the completely revised edition of the market-leading Java exam preparation guide from Sybex! Authors Simon Roberts (the lead author of the Java exams), Philip Heller, and Michael Ernest have completely revamped their book, writing five new chapters on the tough Developer's exam and adding lots of new questions (200 new ones in the book and on the CD). In response to reader feedback, we've cut out the long API reference that was in the previous edition and replaced it with more meaningful content. Finally, the CD now contains a fully searchable electronic edition of the book.
Customer Reviews:
Mistakes, Mistakes, and more Mistakes.......2005-06-06
I find it hard to believe that a study guide this error ridden was ever released given the gross errors my study group has found. We feel a lack of confidence in the material presented in this text and in the authors in particular. We have to verify everything presented in this text and believe nothing to be true without doing so. This is not a good way to study for a certification exam. We need a trusted and reliable reference, not a work of fiction.
We are not at all pleased with the material covered. Nor are we pleased with the mock exams which we all agree are too easy.
In all I would suggest that you not purchase this book and wait instead for the next release of Kathy Sierra & Bert Bates book.
Sample exams on CD are buggy and wrong.......2005-03-01
The exams on the accompanying CD are crap.
The engine is buggy (sometime you cannot see the whole text) and answers are wrong. E.g.
Q: "Which access modifier will allow access only within the class and package?"
A: "friendly"
Maybe friendly, but definitely wrong.
This was all I needed!.......2005-01-25
I studied this book carefully twice through and passed the exam easily. It may not be perfect, but it was all I needed.
Just right for the Programmer's Exam..........2004-11-25
I used this book as my primary study guide for the Programmer Exam and it definitely helped me passing with high score.
This book is just right for this exam and covers all the objectives very well. I would certainly recommend anybody who is planning to prepare for the exam to read this book. Even experienced Java Developers can gain much of the knowledge of Java Language Fundamentals by reading this book.
However, based on my experience with the exam questions, I believe, this book is somewhat light on topics like Garbage Collection and Collections. If you aim to pass with high scores, you need to put more stress on these two topics and hence need to supplement this book with additional resources/tutorials freely available on the Internet. Otherwise, this is just right for the exam.
Too many errors for a 4th Edition.......2004-07-23
Obviously no one made a CURSORY proof-reading of this edition, or they would have seen dozens of double-quotes in the examples appear as some odd character I have never seen before. Once I figured it out I could decode what was meant, but it was a distracting nuisance. Obviously no one made a DETAILED proof-reading of this edition, or they would have seen us taught the size in bits of a double as 16 instead of 64. Obviously no one made a PROGRAMMING proof-reading of this edition, or they would have seen 65 listed as the byte-code of a lower-case 'a' in one of the exam samples, which made me choose "none of the above". Because of the errors which I DID see, I had little confidence in anything else that seemed questionable.
The chapter on Collections (which was probably added in this edition as it is new in 1.4 I believe) was not detailed enough, and didn't satisfactorily answer the chapter's own review questions.
The sample exams were not anything like the real one, which I failed. I kissed that $150 goodbye.
Book Description
If you're an experienced programmer, you already have a rock-solid foundation for learning Java. All you need is a resource that takes your experience into account and explains Java's key principles and techniques in an intelligent, efficient way.
Java: Practical Guide for Programmers is precisely that resource. Here, you won't have to wade through hundreds of pages of overly simplistic material to learn the basics of Java programming. Instead, you get highly focused instruction in the core elements of Java 1.4, accompanied by carefully chosen examples and line-by-line analyses that are right to the point. You'll be astonished at how soon you can begin productive coding in Java, and how quickly your skills will progress.
Web resources:
Source code from the book is no longer available at
http://www.zm.sikora.btinternet.co.uk/source.html
Please press the 'Companion Page' button on the upper right side of this page to access a zip file containing it.
Sun J2SE download page
http://java.sun.com/j2se/downloads.html
Sun J2SE API documentation
http://java.sun.com/j2se/1.4.1/docs/index.html
* Written expressly for people who already know a procedural or object-oriented programming language.
* Takes a concise approach designed to make the most of the experience you already have.
* Covers the core elements of Java 1.4, including language syntax, OO features, collections, exception handling, input/output, threads, event handling, and Swing components.
* Filled with incisive coding examples and line-by-line analyses.
* Via a companion Web site, provides downloadable example code and links to additional resources.
Customer Reviews:
A CONCISE Java Grammar!.......2006-06-01
I love this little one. From time to time, between working through and losing myself in half dozen or more heavy tomes of Java book, I would come back to this little one to get a grip of fundamentals and essentials. The book is concise and no nonsensical. I also like the banking application sample code. Practical enough. Who doesn't bank?
Good for experienced coders.......2006-01-03
As the book's title shows, it's just a guide, a simple guide that you can not expect too much details out from it. Before learning Java, I am a Delphi coder. So, I was looking for some book to transfer me from Delphi to Java quickly. Within merely 170-odd pages, Sikora brings you an overview of the Java language. I think this guide just right fits my taste. Another thing to be mentioned, if you are a serious coder, a detailed reference is necessary. As what I am doing now, Java 2, The Complete Reference is by far the most suitable book for me, after I have an bird's eye view from Sikora's guide.
quickly learn Java?.......2005-09-23
Indeed, Sikora offers a quick start to learning Java. He eshews an exhaustive enumeration of every core class in J2SE. Instead, he takes several high level topics and explains which common classes deal with these. A question arises. Can you indeed learn Java from so slender a book? Perhaps. Sikora teaches a core functionality. Made easier if you have already programmed in some other language.
For graphics, he leads you right into Swing. No time wasted on the earlier and inferior AWT classes.
For input/output, Java is more powerful than C or C++, but concomitantly harder to use. The coding is far more verbose, compared to a simple printf() or scanf() in C, for example. The minimal descriptions in Java given here are admirable in how he found the essence of enough to be useful.
Java for self-starters.......2003-05-12
If I could only recommend one book to an experienced programmer who wanted to learn Java it would be this one. It's only 170 pages long and it doesn't contain anything that's unnecessary. But it does cover syntax, flow control, classes and methods, inheritance, exception handling, file I/O, GUI's, collections and threads. That's genuinely Java in a nutshell.
The author can offer such a stripped-down book, of course, because he assumes that the reader already understands programmatic flow control and objects, and can follow a basic inheritance hierarchy without tedious explanation.
Java isn't a difficult language: it can merely be made to seem so by textbooks that bury simple facts under mountains of verbiage. I hope other authors will take Zbigniew Sikora's "Java: Practical Guide for Programmers" as a model for textbooks for busy people.
Books:
- Security Policies and Procedures: Principles and Practices (Prentice Hall Security Series)
- Spreadsheet Modeling and Decision Analysis (with CD-ROM and Microsoft Project 2003 120 day version)
- SQL Built-In Functions and Stored Procedures: The i5/iSeries Programmer's Guide
- Survey of Accounting: Making Sense of Business
- Swarm Intelligence (The Morgan Kaufmann Series in Artificial Intelligence)
- Teach Yourself VISUALLY Windows Vista (Teach Yourself VISUALLY (Tech))
- Ten Days in the Hills
- The Complete Book Of Gourd Craft: 22 Projects * 55 Decorative Techniques * 300 Inspirational Designs
- The Complete Idiot's Guide to Finance and Accounting (The Complete Idiot's Guide)
- The DV Rebel's Guide: An All-Digital Approach to Making Killer Action Movies on the Cheap (Peachpit)
Books Index
Books Home
Recommended Books
- Firms, Contracts, and Financial Structure
- Alamo in the Ardennes: The Untold Story of the American Soldiers Who Made the Defense of Bastogne Po
- The Iron Triangle: Inside the Secret World of the Carlyle Group
- The Kakuro Challenge 1
- The World Is Flat
- A Perfect Mess: The Hidden Benefits of Disorder--How Crammed Closets, Cluttered Offices, and On-the-
- Wild Bill: The Legend and Life of William O. Douglas
- Analisis E Interpretacion de Estados Contables. Enfocado a Empresas En Crisis, Infracapitalizacion E
- The New Geopolitics of Minerals: Canada and International Resource Trade
- The Widening Gyre
Head First Design Patterns (Head First)
SCJP Exam for J2SE 5: A Concise and Comprehensive Study Guide for The Sun Certified Java Programmer Exam
Head First EJB (Brain-Friendly Study Guides; Enterprise JavaBeans)
