What is the difference between AWT and Swing? LF DC

 Swing provides a richer set of components than AWT. They are 100% Java-based. There are a few other advantages to Swing over AWT:

• Swing provides both additional components like JTable, JTree etc and added functionality to AWT-replacement components.

• Swing components can change their appearance based on the current “look and feel” library that’s being used.

• Swing components follow the Model-View-Controller (MVC) paradigm, and thus can provide a much more

flexible UI.

• Swing provides “extras” for components, such as: icons on many components, decorative borders for

components, tool tips for components etc.

• Swing components are lightweight (less resource intensive than AWT).

Swing provides built-in double buffering (which means an off-screen buffer [image] is used during drawing

and then the resulting bits are copied onto the screen. The resulting image is smoother, less flicker and quicker than drawing directly on the screen).

• Swing provides paint debugging support for when you build your own component i.e.-slow motion rendering.

Swing also has a few disadvantages:

• If you’re not very careful when programming, it can be slower than AWT (all components are drawn).

• Swing components that look like native components might not behave exactly like native components.

"XYz"

Returns: "XYz"

"application"

Returns: "pplctnaiaio"

"qwcvb"

Returns: "qwcvb"

"aeioOa"

Returns: "aeioOa"

import java.util.*;

public class VowelLatin {

public String translate(String word){

char[] chars=word.toCharArray();

String vowels=”aeiouAEIOU”;

StringBuilder end=new StringBuilder();

StringBuilder beg=new StringBuilder();

for(char c:chars){

if(vowels.indexOf(c)>-1){

end.append(c);

}else{

beg.append(c);

}

}

beg.append(end.toString());

return beg.toString();

}

}

Problem Statement

I want a list of BioServices that are associated with each KindOfInput (such as “gene”, “DNAFragment”, “genome”, etc.). What is available from my service provider is a list of strings, each containing the name of a service followed by all the KindsOfInput it requires.
Given a String[] services, return a String[] in which each element contains a KindOfInput followed by the names of all the services that use that kind of input.
Each KindOfInput should appear exactly once in the return. Within each element of the return, the service names should be in alphabetical order, and should be separated by the 2 characters “, ” (comma space). The KindOfInput should be separated from the first service name by the 5 characters ” ==> ” (space eq eq gt space). The returned list should be in alphabetical order.
Note that all names are case-sensitive, and that “alphabetical order” refers to the ASCII ordering, where, for example, ‘Z’ precedes ‘a’.
Definition

Class:
ServiceNames
Method:
makeList
Parameters:
String[]
Returns:
String[]
Method signature:
String[] makeList(String[] services)
(be sure your method is public)

Constraints
-
services will contain between 1 and 50 elements, inclusive.
-
Each element of services will contain between 1 and 50 characters, inclusive.
-
Each element of services will contain tokens separated by a single space (‘ ‘).
-
Each token will consist of 1 or more letters (‘A’-'Z’ or ‘a’-'z’).
-
The first tokens of the elements in services will be distinct.
-
Within each element of services the KindsOfInput will be distinct.
Examples
0)

{“BLAST Genome Annotation Sensitivity”,”PING”,”X Annotation”}
Returns: {“Annotation ==> BLAST, X”, “Genome ==> BLAST”, “Sensitivity ==> BLAST” }

1)

{“PING”}
Returns: { }
There are no KindsOfInput so the return has 0 elements.
2)

{“BLAST Genome annotation Sensitivity”,”PING”,”X Annotation”,”Apple X ample”}
Returns:
{“Annotation ==> X”,
“Genome ==> BLAST”,
“Sensitivity ==> BLAST”,
“X ==> Apple”,
“ample ==> Apple”,
“annotation ==> BLAST” }
annotation and Annotation are distinct kinds of input. annotation comes later alphabetically than any name that starts with an uppercase letter.

Solution:

import java.util.*;

public class ServiceNames {
public String[] makeList(String[] services){
HashMap<String,HashSet<String>> map=new HashMap<String,HashSet<String>>();
for(String service:services){
String[] comp=service.split(” “);
if(comp.length<2) continue;
HashSet<String> list=null;
for(int i=1;i<comp.length;i++){
if(!map.containsKey(comp[i])){
map.put(comp[i], new HashSet<String>());
}
list=map.get(comp[i]);
list.add(comp[0]);
}
}
ArrayList<String> ret=new ArrayList<String>();
StringBuilder result=new StringBuilder();
String[] keys=map.keySet().toArray(new String[0]);
for(String key:keys){
result=new StringBuilder(key+” ==> “);
HashSet<String> vals=map.get(key);
String[] svals=vals.toArray(new String[0]);
if(svals.length==0) continue;
Arrays.sort(svals);
result.append(svals[0]);
for(int i=1;i<svals.length;i++){
result.append(“, “+svals[i]);
}
ret.add(result.toString());
}
String[] sret=ret.toArray(new String[0]);
Arrays.sort(sret);
return sret;

}
}