Related
So, I am making an application where I saved details of a client such as first name, surname, DOB, ID and address into a file called "clientListFile.txt". Everytime, a client information is added to the file there is an empty space before and after the information as shown below:
//empty line
//empty line
fn
sn
1900-08-01
1234
addressname
s
8
hn
a
pc
t
country
//empty line
//empty line
fn1
sn1
1900-08-02 ... (etc)
In the code below, I am able to find if a string is stored into the file. For example, in my program, if I search "fn" or if I search "1234", it prints out which line it is located on. However, I want it to print out everything in the JTextArea called "jDisplaySearchedClientsTextArea" between the first two empty lines and the last two empty lines.
private void jSearchClientsButtonActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
String fn = jClientsFNTextField.getText();
String clientListFile = "clientListFile.txt";
try {
BufferedReader areader = new BufferedReader(new FileReader(new File(clientListFile)));
Scanner scanner = new Scanner(clientListFile);
//now read the file line by line...
int lineNum = 0;
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
lineNum++;
if (fn.equals(areader.readLine())) {
System.out.println("ho hum, i found it on line " +lineNum);
}
}
}
catch (IOException ioe) {
System.out.println("Error while saving Head Office Address");
}
}
You might use a method something like this:
/**
* Parses and searches a "clientListFile.txt" data file based on the supplied
* search criteria.<br>
*
* #param dataFilePath (String) The full path and file name of the data file
* to search in.<br>
*
* #param searchCriteria (String) What to search for in each data record
* contained within the supplied data file.<br>
*
* #param useContains (Optional - Boolean - Default is True) This optional
* parameter by default is boolean '<b>true</b>'. This means that every search
* done in any data file record is carried out by locating the search criteria
* (ignoring letter case) within any record field value location that <u><b>contains</b></u>
* the search criteria. An example
* of this would be:<pre>
*
* Search Criteria: "fred"
*
* A Data Record:
* =============
* First Name: Danny (No Match)
* Surname: Fredrikson (Match - Fred......)
* Birthdate: 1957-11-07 (No Match)
* Cient ID: 1234 (No Match)
* Address: 3233 Sandy St. (No Match)
* City: Fredericton (Match - Fred.......)
* Province: New Brunswick (No Match)
* etc.....</pre><br>
*
* If boolean '<b>false</b>' is optionally supplied then the search is done
* based on <u><b>equality</b></u>. This means that every search done in any data file
* record is carried out by locating the search criteria within any record
* field value that is <b>equal to</b> (ignoring letter case) the supplied
* search criteria. An example of this would be:<pre>
*
* Search Criteria: "fred"
*
* A Data Record:
* =============
* First Name: Fred (Match - Fred)
* Surname: Fredrikson (No Match)
* Birthdate: 1957-11-07 (No Match)
* Cient ID: 1234 (No Match)
* Address: 3233 Sandy St. (No Match)
* City: Fredericton (No Match)
* Province: New Brunswick (No Match)
* etc.....</pre><br>
*
* #return A List Interface Object of Type String - {#code List<String>}.
*/
public static List<String> searchInRecords(String dataFilePath, String searchCriteria, boolean... useContains) {
boolean UseCONTAINSinSearches = true;
if (useContains.length > 0) {
UseCONTAINSinSearches = useContains[0];
}
int fileLinesCounter = 0;
int fieldsCounter = 0;
int dataRecordsCounter = 0;
int criterialFoundRecords = 0;
boolean inRecord = false;
List<String> foundRecords = new ArrayList<>();
String[] fields = new String[12];
// 'Try With Resources' use here to auto-close the reader.
try (BufferedReader reader = new BufferedReader(new FileReader(dataFilePath))) {
String line;
while ((line = reader.readLine()) != null) {
fileLinesCounter++;
line = line.trim();
if (line.isEmpty() && fieldsCounter == 0) {
inRecord = true;
}
else if (inRecord && fieldsCounter <= 11) {
fields[fieldsCounter] = line;
if (fieldsCounter == 11) {
String record = new StringBuilder("").append(fields[0]).append(", ")
.append(fields[1]).append(", ").append(fields[2]).append(", ")
.append(fields[3]).append(", ").append(fields[4]).append(", ")
.append(fields[5]).append(", ").append(fields[6]).append(", ")
.append(fields[7]).append(", ").append(fields[8]).append(", ")
.append(fields[9]).append(", ").append(fields[10]).append(", ")
.append(fields[11]).toString();
dataRecordsCounter++;
// Search Type 1 (using CONTAINS where criteria is anywhere in a field)
if (UseCONTAINSinSearches) {
for (String field : fields) {
if (field == null) { continue; }
if (field.toLowerCase().contains(searchCriteria)) {
if (!foundRecords.contains(record)) {
foundRecords.add(record);
criterialFoundRecords++;
}
}
}
}
// Search Type 2 (using exact match to field but ignoring letter case)
else {
for (String field : fields) {
if (field == null) { continue; }
if (field.equalsIgnoreCase(searchCriteria)) {
if (!foundRecords.contains(record)) {
foundRecords.add(record);
criterialFoundRecords++;
}
}
}
}
}
fieldsCounter++;
}
else {
fieldsCounter = 0;
inRecord = false;
}
}
}
// Handle the exceptions (if any) any way you see fit.
catch (FileNotFoundException ex) {
System.err.println(ex);
}
catch (IOException ex) {
System.err.println(ex);
}
/* The following integer type variables can be used to supply related
class member variables. They serve no specific purpose within this
method and can be removed if desired. Sometimes this information can
be handy. */
System.out.println("Overall Number of Data File Lines: --> " + fileLinesCounter);
System.out.println("Overall Number of Records in File: --> " + dataRecordsCounter);
System.out.println("Criterial Search - Records Found: --> " + criterialFoundRecords);
return foundRecords;
}
Far better of course to utilize a database for this sort of thing and the use of a Client class. Even with a file type data storage method (like you are using), you would really want a Client class to keep that data organized and store the data more like in a CSV style (Comma Separated Values) file. Here is an example of a custom CSV data file:
Client ID, First Name, Sir Name, Date Of Birth, Address, City, State/Province, Postal Code, Country, E-Mail, Phone Number
=======================================================================================================================================================================================
1234, Fred, Flinstone, 1957-11-07, 2977 Oriole Cooky Way, Bedrock, Stones Throw, V2Q5W8, Canada, his-email#yahoo.com, 604-776-1121
1235, Wilma, Flinstone, 1964-11-30, 2977 Oriole Cooky Way, Bedrock, Stones Throw, V2Q5W8, Canada, her-email#yahoo.com, 604-776-3466
1236, Jack, Naso, 1993-03-18, 33912 CrackShack Ave, Vancouver, British Columbia, V2Z1D2, Canada, myemailaddy#hotmail.com, 856-302-1122
1237, William, Shakaconn, 1996-12-13, 1212 Playwrite Street, Langely, British Columbia, V2T4C9, Canada, playme#gmail.ca, 777-664-9351
In this custom CSV file the data is laid out more like a table and records are more legible even when just reading the file itself. If you want your Client class to do this sort of thing then just E-Mail me.
Here I want to convert the JSON file into RDF. Here is the JSON
{
"glossary": {
"title": "example glossary",
"GlossDiv": {
"title": "S",
"GlossList": {
"GlossEntry": {
"ID": "SGML",
"SortAs": "SGML",
"GlossTerm": "Standard Generalized Markup Language",
"Acronym": "SGML",
"Abbrev": "ISO 8879:1986",
"GlossDef": {
"para": "A meta-markup language, used to create markup languages such as DocBook.",
"GlossSeeAlso": ["GML", "XML"]
},
"GlossSee": "markup"
}
}
}
}
}
I could not find a proper way to convert it into RDF.
There is no standard way to interpret JSON as RDF. There are several ways you can generate RDF from a JSON file though (in Java or otherwise). You could simply use a JSON parser implemented in Java, then extract the relevant parts and build an RDF graph using a Java library for RDF such as Apache Jena or RDF4J (formerly known as Sesame). However, there are other ways that could make the task much easier:
Transform the JSON file into a JSON-LD file by adding a #context to it. This works well for simple cases but is not sufficient to cover many relevant cases.
Use RML, a language for expressing mappings from various data formats (including JSON) to RDF. It has a reference implementation in Java. RML is an extension of R2RML, so it can also map relational data to RDF, and if you are familiar with R2RML, it is relatively easy to understand how RML works. There is also a graphical editor, but it seems it is not available for download.
Use SPARQL-Generate, a language for expressing mappings from non-RDF data sources (including JSON) to RDF. It has a reference implementation based on Jena. It extends SPARQL, so if you are familiar with SPARQL, it should be quite easy to use it. It can be tested online.
Disclaimer: I contributed to SPARQL-Generate.
If your aim is to simply get valid RDF without making any decisions about structure, you could trivially add a #context object and turn the existing JSON into JSON-LD, e.g.
{
"#context": {"#vocab": "http://example.org/ontology#"},
"glossary": {
"title": "example glossary",
"GlossDiv": {
"title": "S",
"GlossList": {
"GlossEntry": {
"ID": "SGML",
"SortAs": "SGML",
"GlossTerm": "Standard Generalized Markup Language",
"Acronym": "SGML",
"Abbrev": "ISO 8879:1986",
"GlossDef": {
"para": "A meta-markup language, used to create markup languages such as DocBook.",
"GlossSeeAlso": ["GML", "XML"]
},
"GlossSee": "markup"
}
}
}
}
}
This can then be interpreted as RDF using an appropriate RDF/JSON-LD library, the RDF structure would be:
#prefix ns0: <http://example.org/ontology#> .
[] ns0:glossary [
ns0:GlossDiv [
ns0:GlossList [ ns0:GlossEntry [
ns0:Abbrev "ISO 8879:1986" ;
ns0:Acronym "SGML" ;
ns0:GlossDef [
ns0:GlossSeeAlso "GML", "XML" ;
ns0:para "A meta-markup language, used to create markup languages such as DocBook."
] ;
ns0:GlossSee "markup" ;
ns0:GlossTerm "Standard Generalized Markup Language" ;
ns0:ID "SGML" ;
ns0:SortAs "SGML"
] ] ;
ns0:title "S"
] ;
ns0:title "example glossary"
] .
This is perhaps strange RDF, but it can be loaded and manipulated using RDF tools.
You can play with the example in the json-ld playground
You can convert the JSON file into RDF using RML.
To achieve that, you need to create some mapping rules first.
These mapping rules are used by an RML processor to transform your input data
into RDF. An example of an RML processor is the
RML mapper.
Create an RML LogicalSource.
This describes how and where the RML processor should access the input data:
<#LogicalSource>
a rml:logicalSource;
rml:source "data.json";
rml:referenceFormulation ql:JSONPath;
rml:iterator "$.glossary".
This RDF snippet tells an RML processor that he has to retrieve data.json and
iterate over the data with a JSONPath expression (ql:JSONPath) which is
specified by rml:iterator.
Create a TriplesMap. This provides
an RML processor information about how the input data should be transformed into
RDF. An example is given for the provided data:
<#GlossaryMapping>
a rr:TriplesMap;
rml:logicalSource <#LogicalSource>;
rr:subjectMap [
rr:template "http://example.org/glossary/{title}";
];
rr:predicateObjectMap [
rr:predicate ex:title;
rr:objectMap [
rml:reference "title";
];
].
The TriplesMap uses the created LogicalSource to access the data. The TriplesMap
will make sure that an RML processor creates triples with
http://example.org/glossary/{title} as subject, ex:title as predicate and
the value of the JSON property title as object
TriplesMaps can also be linked with each other.
If you have an entry of a list (GlossEntry) to a higher element glossary for
example, you can write the following mapping rules:
<#GlossaryMapping>
a rr:TriplesMap;
rml:logicalSource <#LogicalSource>;
rr:subjectMap [
rr:template "http://example.org/glossary/{title}";
];
rr:predicateObjectMap [
rr:predicate ex:glossDiv;
rr:objectMap [
rr:parentTriplesMap <#GlossListEntryMapping>;
rr:child "GlossDiv.title";
rr:parent "GlossDiv.title";
];
].
<#GlossListEntryMapping>
a rr:TriplesMap;
rml:logicalSource <#LogicalSource>;
rr:subjectMap [
rr:template "http://example.org/entry/{GlossDiv.title}";
];
Both TriplesMaps will be joined with each other taking into account the provided
rr:joinCondition. If no join condition is provided, every subject of the child
will be joined with every subject of the parent.
Mapping rules
I left out some JSON properties in this full example to keep it concise.
#base <http://example.org> .
#prefix rr: <http://www.w3.org/ns/r2rml#> .
#prefix rml: <http://semweb.mmlab.be/ns/rml#> .
#prefix ql: <http://semweb.mmlab.be/ns/ql#> .
#prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
#prefix ex: <http://example.org/ns#> .
<#LogicalSource>
a rml:logicalSource;
rml:source "data.json";
rml:referenceFormulation ql:JSONPath;
rml:iterator "$.glossary".
<#GlossaryMapping>
a rr:TriplesMap;
rml:logicalSource <#LogicalSource>;
rr:subjectMap [
rr:template "http://example.org/glossary/{title}";
];
rr:predicateObjectMap [
rr:predicate ex:title;
rr:objectMap [
rml:reference "title";
];
];
rr:predicateObjectMap [
rr:predicate ex:glossDiv;
rr:objectMap [
rr:parentTriplesMap <#GlossListEntryMapping>;
rr:child "GlossDiv.title";
rr:parent "GlossDiv.title";
];
].
<#GlossListEntryMapping>
a rr:TriplesMap;
rml:logicalSource <#LogicalSource>;
rr:subjectMap [
rr:template "http://example.org/entry/{GlossDiv.title}";
];
rr:predicateObjectMap [
rr:predicate ex:ID;
rr:objectMap [
rml:reference "GlossDiv.GlossList.GlossEntry.ID"
];
];
rr:predicateObjectMap [
rr:predicate ex:Abbrev;
rr:objectMap [
rml:reference "GlossDiv.GlossList.GlossEntry.Abbrev"
];
];
# Other properties can be mapped too if needed
rr:predicateObjectMap [
rr:predicate ex:glossSeeAlso;
rr:objectMap [ # Mapping arrays can also be done
rml:reference "GlossDiv.GlossList.GlossEntry.GlossDef.GlossSeeAlso.[*]";
];
].
Output
<http://example.org/entry/S> <http://example.org/ns#glossSeeAlso> "GML".
<http://example.org/entry/S> <http://example.org/ns#glossSeeAlso> "XML".
<http://example.org/entry/S> <http://example.org/ns#ID> "SGML".
<http://example.org/entry/S> <http://example.org/ns#Abbrev> "ISO 8879:1986".
<http://example.org/glossary/example%20glossary> <http://example.org/ns#title> "example glossary".
<http://example.org/glossary/example%20glossary> <http://example.org/ns#glossDiv> <http://example.org/entry/S>.
Note: I contribute to RML and its technologies.
If I understand your question correctly, I recommend using Apache Jena, Apache's open source semantic web library.
Here is an RDF creation tutorial.
I've also found JSON2RDF, a project that claims to utilize Jena in creating a declerative language for converting JSONs into RDFs, but I have not tested it myself and the docs are vague. Please share your experience if you do end up looking into it.
We have released open-source JSON2RDF converter (not to be confused with the JSON2RDF mentioned by vaiden) that allows you to do exactly that:
https://github.com/AtomGraph/JSON2RDF
JSON2RDF + SPARQL can be used as a more flexible alternative to JSON-LD + #context.
We're providing a JSON to JSONLD converting service: https://json2ld.mapper.tokyo/
First, you paste or upload your JSON data, then it instantly generates their JSONLD version.
It automatically maps some existing vocabularies such as schema.org if there's a matching term in the JSON data such as "name", which is mapped to https://schema.org/name.
You can edit which vocabularies or terms are mapped and publish your context from your GitHub repo.
I spent some time recently to paste some older java code together to create a command line tool named 'oi'.
https://github.com/jschnasse/oi
Call
oi stack44753298.json -t turtle
Prints
_:b0 <info:oi/glossary> _:b1 .
_:b1 <info:oi/GlossDiv> _:b2 .
_:b2 <info:oi/GlossList> _:b3 .
_:b3 <info:oi/GlossEntry> _:b4 .
_:b4 <info:oi/Abbrev> "ISO 8879:1986";
<info:oi/Acronym> "SGML";
<info:oi/GlossDef> _:b5 .
_:b5 <info:oi/GlossSeeAlso> "GML", "XML";
<info:oi/para> "A meta-markup language, used to create markup languages such as DocBook." .
_:b4 <info:oi/GlossSee> "markup";
<info:oi/GlossTerm> "Standard Generalized Markup Language";
<info:oi/ID> "SGML";
<info:oi/SortAs> "SGML" .
_:b2 <info:oi/title> "S" .
_:b1 <info:oi/title> "example glossary" .
The tool uses a very rough approach to transform rdf to json and vice versa. For the json to rdf case it creates an adhoc context just by putting all json keys into an info:namespace. After that it uses the context to read in the json as jsonld. Exactly like already described in this thread by brinxmat.
It follows roughly the ideas I wrote up in recent stackoverflow threads:
How do I add a start and end time to a RDF triple?
How to convert RDF to pretty nested JSON using java rdf4j
Read JSON with this JSON parser to Java objects and create rdf with Java objects which is previously read.
package your_package;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.nio.charset.Charset;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
<html>
/**
* JSON is an open standard format that uses human-readable text to transmit
* Data objects consisting of attribute–value pairs. It is used primarily to
* Transmit data between a server and web application, as an alternative to XML.
*
* JSON's basic types are:
* <ul>
* <li><b>Number</b>: a signed decimal number that may contain a fractional part
* And may use exponential E notation. JSON does not allow non-numbers like NaN,
* Nor does it make any distinction between integer and floating-point. (Even
* Though JavaScript uses a double-precision floating-point format for all its
* Numeric values, other languages implementing JSON may encode numbers
* differently) </li>
* <li><b>String</b>: a sequence of zero or more Unicode characters. Strings are
* Delimited with double-quotation marks and support a backslash escaping
* syntax.</li>
* <li><b>Boolean</b>: either of the values {#code true} or {#code false}</li>
* <li><b>Array</b>: an ordered list of zero or more values, each of which may
* Be of any type. Arrays use square bracket notation with elements being
* comma-separated.</li>
* <li><b>Object</b>: an unordered collection of name/value pairs where the
* Names (also called keys) are strings. Since objects are intended to represent
* Associative arrays, it is recommended, though not required, that each key is
* Unique within an object. Objects are delimited with curly brackets and use
* Commas to separate each pair, while within each pair the colon {#code ':'}
* Character separates the key or name from its value.</li>
* <li><b>null</b>: An empty value, using the word null</li>
* </ul>
* Conversion table:
* <table border='1'>
* <tr><td>java.util.Map</td><td>JSON Object {"key":[0,2,3]}</td></tr>
* <tr><td>java.util.Collection</td><td>JSON Array [0,1,2,"string"]</td></tr>
* <tr><td>java.lang.String</td><td>JSON String "example"</td></tr>
* <tr><td>java.lang.Boolean</td><td>JSON Boolean (true/false) </td></tr>
* <tr><td>java.lang.Number</td><td>JSON Number (-2.5E2) </td></tr>
* <tr><td>null</td><td>JSON Null (null) </td></tr>
* </table>
* Any other object will be write with the next formula:
* <u>{#code obj.toString()}</u>. For example:
* {#Code write (out, new java.lang.object())}. The output stream will be
* Contains the hashcode of newly created object because the default object
* toString() method returns the object hashcode. This class supported the
* Duplicated keys in the object map.
*
* The JavaScript Object Notation (JSON) Data Interchange Format:
* <A href='http://tools.ietf.org/html/rfc7159'>RFC-7159</a>
*
* #See DuplicatedKeyList
*/
public class Json {
/**
* This field represents when the json object is finished, no more available
* data to processing.
*/
private static final Object close = new Object();
/**
* The step offsets in the rows.
*/
private static final int writeSpaceCount = 1;
/**
* 'n' 'u' 'l' 'l'
*/
public static final byte[] NULL = new byte[]{'n', 'u', 'l', 'l'};
/**
* The null identifer, also called: the first character of null.
*/
public static final int NULL_LOWER = 'n';
/**
* The null identifer, also called: the first character of null (uppercase).
*/
public static final int NULL_UPPER = 'N';
/**
* The first character of {#code true}.
*/
public static final int TRUE = 't';
/**
* The first character of {#code true} (uppercase).
*/
public static final int TRUE_UPPER = 'T';
/**
* The first character of {#code false}.
*/
public static final int FALSE = 'f';
/**
* The first character of {#code false} (uppercase).
*/
public static final int FALSE_UPPER = 'F';
/**
* Colon ascii value
*/
public static final int COLON = ':';
/**
* Comma ascii value
*/
public static final int COMMA = ',';
/**
* left bracket (the list identifier, first character)
*/
public static final int LEFT_BRACKET = '[';
/**
* left brace (the map identifier, first character)
*/
public static final int LEFT_BRACE = '{';
/**
* right bracket (the list identifier, last character)
*/
public static final int RIGHT_BRACKET = ']';
/**
* right bracket (the map identifier, last character)
*/
public static final int RIGHT_BRACE = '}';
/**
* the string identifier: {#code "}
*/
public static final int STRING = '"';
/**
* the space ascii value
*/
public static final int SP = ' ';
/**
* the backslash ascii value
*/
public static final int BS = '\\';
/**
* the CR (carriage return) ascii value
*/
public static final int CR = 13;
/**
* the line feed ascii value
*/
public static final int LF = 10;
/**
* the end of file identifier
*/
public static final int EOF = -1;
/**
* end of line identifier (CR + LF)
*/
public static final byte[] EOL = new byte[]{CR, LF};
/**
* the byte array buffer to read
*/
private final ByteArrayOutputStream buf = new ByteArrayOutputStream();
/**
* Creates a new JSON which can read and write json objects.
*/
public Json() {
}
/**
* Creates a new empty map.
*
* #return a new empty map.
*/
private Map createEmptyMap() {
return new HashMap();
}
/**
* Writes a specified object {#code obj} to a specified output stream
* {#code out}, also called: creates a json document from the specified
* object. Duplicated keys are supported. Conversion table: see JSON class
* javadoc.
*
* #param out the specified output stream
* #param obj the specified object
* #throws IOException If IO Error Occurs.
* #see Json
*/
public void write(PrintStream out, Object obj) throws IOException {
write(out, obj, false);
}
/**
* Writes a specified object {#code obj} to a specified print stream
* {#code out}, also called: creates a json document from the specified
* object. Duplicated keys are supported. Conversion table: see JSON class
* javadoc.
*
* #param out the specified print stream
* #param obj the specified object
* #param format {#code true} if the output is formatted, otherwise
* {#code false}.
* #throws IOException If IO Error Occurs.
* #see Json
* #see DuplicatedKeyList
*/
public void write(PrintStream out, Object obj, boolean format) throws IOException {
write(out, obj, format, 0);
}
/**
* Writes a specified object {#code obj} to a specified print stream
* {#code out}, also called: creates a json document from the specified
* object. Duplicated keys are supported. Conversion table: see JSON class
* javadoc.
*
* #param out the specified print stream
* #param obj the specified object
* #param format {#code true} if the output is formatted, otherwise
* {#code false}.
* #param charset the charset which represents the json document encodings
* #param depth the current depth from the root element
* #throws IOException If IO Error Occurs.
* #see Json
* #see DuplicatedKeyList
*/
private synchronized void write(PrintStream out, Object obj, boolean format, int depth) throws IOException {
if (obj == null) {
out.write(NULL);
out.flush();
return;
}
if (obj instanceof String) {
out.write(STRING);
out.print(escape((String) obj));
out.write(STRING);
out.flush();
return;
} else if (obj instanceof Map) {
out.write(LEFT_BRACE);
Map map = (Map) obj;
Iterator<Map.Entry> it = map.entrySet().iterator();
Map.Entry entry;
while (it.hasNext()) {
entry = it.next();
String key = escape(entry.getKey().toString());
Object val = entry.getValue();
if (val instanceof DuplicatedKeyList) {
writeMulti(out, key, (List) val, format, depth);
} else {
if (format) {
writeBreak(out, depth + writeSpaceCount);
}
write(out, key, format, depth + writeSpaceCount);
out.write(COLON);
if (format) {
writeSpace(out, writeSpaceCount);
}
write(out, val, format, depth + writeSpaceCount);
}
if (it.hasNext()) {
out.write(COMMA);
}
}
if (format) {
writeBreak(out, depth);
}
out.write(RIGHT_BRACE);
out.flush();
return;
} else if (obj instanceof Collection) {
out.write(LEFT_BRACKET);
Iterator it = ((Collection) obj).iterator();
while (it.hasNext()) {
if (format) {
writeBreak(out, depth + writeSpaceCount);
}
write(out, it.next(), format, depth + writeSpaceCount);
if (it.hasNext()) {
out.write(COMMA);
}
}
if (format) {
writeBreak(out, depth);
}
out.write(RIGHT_BRACKET);
out.flush();
return;
}
if (obj instanceof Number || obj instanceof Boolean) {
out.print(obj);
} else {
out.write(STRING);
out.print(escape(obj.toString()));
out.write(STRING);
}
out.flush();
}
/**
* Reads a specified input stream {#code in} which contains json elements
* and returns the java object representation of json elements. Conversion
* table: see JSON class javadoc.
*
* #param in the specified input stream
* #return the java object representation of json elements.
* #throws IOException If IO Error Occurs.
* #see Json
* #see DuplicatedKeyList
*/
public Object read(InputStream in) throws IOException {
return read(in, Charset.forName("UTF-8"));
}
/**
* Reads a specified input stream {#code in} which contains json elements
* and returns the java object representation of json elements. Conversion
* table: see JSON class javadoc.
*
* #param in the specified input stream
* #param charset the json document encodings
* #return the java object representation of json elements.
* #throws IOException If IO Error Occurs.
* #see Json
* #see DuplicatedKeyList
*/
public synchronized Object read(InputStream in, Charset charset) throws IOException {
int b;
while ((b = in.read()) != EOF) {
if (b > 32 && b != COMMA) {
switch (b) {
//list
case LEFT_BRACKET: {
List list = new ArrayList();
Object obj;
while ((obj = read(in, charset)) != close) {
if (obj instanceof Finish) {
list.add(((Finish) obj).val);
break;
} else {
list.add(obj);
}
}
return list;
}
//map
case LEFT_BRACE: {
Map map = createEmptyMap();
Object key;
Object val;
while ((key = read(in, charset)) != close) {
while ((b = in.read()) != COLON) {
if (b == EOF) {
throw new IOException("EOF");
}
}
val = read(in, charset);
if (map.containsKey(key)) {
Object prev = map.get(key);
DuplicatedKeyList list;
if (prev instanceof DuplicatedKeyList) {
list = (DuplicatedKeyList) prev;
//((DuplicatedKeyList) prev).add(val);
} else {
list = new DuplicatedKeyList(new ArrayList());
list.add(prev);
}
list.add(val);
map.put(key, list);
//}
System.err.println("WARNING: duplicated key: " + key);
} else {
if (val instanceof Finish) {
val = ((Finish) val).val;
map.put(key, val);
break;
} else {
map.put(key, val);
}
}
}
return map;
}
//string
case STRING: {
buf.reset();
int a = 0;
while ((b = in.read()) != STRING || a == BS) {
buf.write(b);
a = b;
}
return unescape(buf.toString(charset.name()));
}
case TRUE_UPPER: {
}
//true
case TRUE: {
in.skip(4);
return true;
}
//false
case FALSE_UPPER: {
}
case FALSE: {
in.skip(5);
return false;
}
//null
case NULL_UPPER: {
}
case NULL_LOWER: {
in.skip(4);
return null;
}
//map right brackets
case RIGHT_BRACE: {
}
case RIGHT_BRACKET: {
return close;
}
//number
default: {
buf.reset();
buf.write(b);
while ((b = in.read()) != EOF) {
if (isRegular(b)) {
buf.write(b);
} else {
break;
}
}
String str = buf.toString(charset.name());
Number num;
if (str.indexOf('.') != -1) {
num = Double.valueOf(str);
} else {
num = Long.valueOf(str);
}
if (b == RIGHT_BRACKET || b == RIGHT_BRACE) {
return new Finish(num);
}
return num;
}
}
}
}
return close;
}
private void writeMulti(PrintStream out, Object key, Collection value, boolean format, int depth) throws IOException {
Iterator it = value.iterator();
while (it.hasNext()) {
if (format) {
writeBreak(out, depth + writeSpaceCount);
}
write(out, key, format, depth + writeSpaceCount);
out.write(COLON);
if (format) {
writeSpace(out, writeSpaceCount);
}
write(out, it.next(), format, depth + writeSpaceCount);
if (it.hasNext()) {
out.write(COMMA);
}
}
}
/**
* Returns {#code true} if the specified {#code b} byte is regular
* character, otherwise {#code false}.
*
* #param b the specified byte
* #return {#code true} if the specified {#code b} byte is regular
* character, otherwise {#code false}.
*/
private boolean isRegular(int b) {
return b > 32
&& b != LEFT_BRACKET
&& b != LEFT_BRACE
&& b != COMMA
&& b != RIGHT_BRACKET
&& b != RIGHT_BRACE;
}
/**
* Returns the unescaped string.
*
* #param str the input source
* #return the unescaped string.
*/
private String unescape(String str) {
str = str.replace("\\b", "\b");
str = str.replace("\\f", "\f");
str = str.replace("\\n", "\n");
str = str.replace("\\r", "\r");
str = str.replace("\\t", "\t");
str = str.replace("\\\"", "\"");
return str;
}
/**
* Returns the escaped string.
*
* #param str the input source
* #return the escaped string.
*/
public static String escape(String str) {
str = str.replace("\b", "\\b");
str = str.replace("\f", "\\f");
str = str.replace("\n", "\\n");
str = str.replace("\r", "\\r");
str = str.replace("\t", "\\t");
str = str.replace("\"", "\\\"");
return str;
}
/**
* Writes spaces to a specified output {#code out}.
*
* #param out the specified output
* #param spaceCount the spaces count
* #throws IOException if IO Error Occurs.
*/
private void writeSpace(OutputStream out, int spaceCount) throws IOException {
byte[] b = new byte[spaceCount];
for (int i = 0; i < b.length; i++) {
b[i] = SP;
}
out.write(b);
}
/**
* Writes break line and spaces to a specified output {#code out}.
*
* #param out the specified output
* #param spaceCount the spaces count
* #throws IOException if IO Error Occurs.
*/
private void writeBreak(OutputStream out, int spaceCount) throws IOException {
out.write(EOL);
writeSpace(out, spaceCount);
}
/**
* Creates a new instance of JSON.
*
* #return a new instance of JSON.
*/
public static Json getInstance() {
return new Json();
}
public Object read(byte[] b) throws IOException {
return read(new ByteArrayInputStream(b));
}
/**
* This class can contains json elements to one key. json objects (map) can
* contains duplicate values to one key.
*/
public static class DuplicatedKeyList extends AbstractList {
private List list;
public DuplicatedKeyList(List list) {
if (list == null) {
throw new NullPointerException("list is null");
}
this.list = list;
}
#Override
public void add(int index, Object element) {
list.add(index, element);
}
#Override
public Object set(int index, Object element) {
return list.set(index, element);
}
#Override
public Object remove(int index) {
return list.remove(index);
}
#Override
public Object get(int index) {
return list.get(index);
}
#Override
public int size() {
return list.size();
}
#Override
public String toString() {
Iterator it = iterator();
if (!it.hasNext()) {
return "[]";
}
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
sb.append('#').append('=');
Object e = it.next();
sb.append(e == this ? "(this Collection)" : e);
if (!it.hasNext()) {
return sb.append(']').toString();
}
sb.append(',').append(' ');
}
}
}
/**
* This class is a marker class which must use if the json collection (map
* or list) will be finished.
*/
class Finish {
/**
* the last object
*/
private Object val;
/**
* Creates a new instance with the specified {#code val} value.
*
* #param val the specified value
*/
public Finish(Object val) {
this.val = val;
}
}
}
This code works, but with a try/catch box .
public enum AccentuationUTF8 {/** */
é, /** */è, /** */ç, /** */à, /** */ù, /** */
ä, /** */ë, /** */ö, /** */ï, /** */ü, /** */
â, /** */ê, /** */î, /** */ô, /** */û, /** */
}
......
final EnumSet<AccentuationUTF8> esUtf8 = EnumSet.noneOf(AccentuationUTF8.class);
final String[] acc1 = {"é", "à", "u"};
for (final String string : acc1) {
try { // The ontologic problem
esUtf8.add(AccentuationUTF8.valueOf(string));
} catch (final Exception e) {
System.out.println(string + " not an accent.");
}
}
System.out.println(esUtf8.size() + "\t" + esUtf8.toString()
output :
u not an accent.
2 [é, à]
I want to generate an EnumSet with all accents of a word or of sentence.
Edit after comments
Is it possible to manage such an EnumSet without using try (needed by AccentuationUTF8.valueOf(string)?
Is better way to code ?
FINAL EDIT
Your responses suggest me a good solution : because EnumSet.contains(Object), throw an Exception, change it : create a temporary HashSet able to return a null without Exception.
So the ugly try/catch is now removed, code is now :
final Set<String> setTmp = new HashSet<>(AccentsUTF8.values().length);
for (final AccentsUTF8 object : AccentsUTF8.values()) {
setTmp.add(object.toString());
}
final EnumSet<AccentsUTF8> esUtf8 = EnumSet.noneOf(AccentsUTF8.class);
final String[] acc1 = {"é", "à", "u"};
for (final String string : acc1) {
if (setTmp.contains(string)) {
esUtf8.add(AccentsUTF8.valueOf(string));
} else {
System.out.println(string + " not an accent.");
}
}
System.out.println(esUtf8.size() + "\t" + esUtf8.toString()
Thanks for attention you paid for.
I don't think an enum is the best approach here - partly because it's only going to work for valid Java identifiers.
It looks like what you really want is just a Set<Character>, with something like:
Set<Character> accentsInText = new HashSet<Character>();
for (int i = 0; i < text.length(); i++) {
Character c = text.charAt(i);
if (ALL_ACCENTS.contains(c)) {
accentsInText.add(c);
}
}
This code takes in users and movies from two separate files and computes a user score for a movie. When I run the code I get the following error:
Exception in thread "main" java.lang.NullPointerException
at RecommenderSystem.makeRecommendation(RecommenderSystem.java:75)
at RecommenderSystem.main(RecommenderSystem.java:24)
I believe the NullPointerException is due to an error in this particular class but I can't spot it. Any thoughts?
import java.io.*;
import java.lang.Math;
public class RecommenderSystem
{
private Movie[] m_movies;
private User[] m_users;
/** Parse the movies and users files, and then run queries against them.
*/
public static void main(String[] argv)
throws FileNotFoundException, ParseError, RecommendationError
{
FileReader movies_fr = new FileReader("C:\\workspace\\Recommender\\src\\IMDBTop10.txt");
FileReader users_fr = new FileReader("C:\\workspace\\Recommender\\src\\IMDBTop10-users.txt");
MovieParser mp = new MovieParser(movies_fr);
UserParser up = new UserParser(users_fr);
Movie[] movies = mp.getMovies();
User[] users = up.getUsers();
RecommenderSystem rs = new RecommenderSystem(movies, users);
System.out.println("Alice would rate \"The Shawshank Redemption\" with at least a "
+ rs.makeRecommendation("The Shawshank Redemption", "asmith"));
System.out.println("Carol would rate \"The Dark Knight\" with at least a "
+ rs.makeRecommendation("The Dark Knight", "cd0"));
}
/** Instantiate a recommender system.
*
* #param movies An array of Movie that will be copied into m_movies.
* #param users An array of User that will be copied into m_users.
*/
public RecommenderSystem(Movie[] movies, User[] users)
throws RecommendationError
{
m_movies = movies;
m_users = users;
}
/** Suggest what the user with "username" would rate "movieTitle".
*
* #param movieTitle The movie for which a recommendation is made.
* #param username The user for whom the recommendation is made.
*/
public double makeRecommendation(String movieTitle, String username)
throws RecommendationError
{
int userNumber;
int movieNumber;
int j=0;
double weightAvNum =0;
double weightAvDen=0;
for (userNumber = 0; userNumber < m_users.length; ++userNumber)
{
if (m_users[userNumber].getUsername().equals(username))
{
break;
}
}
for (movieNumber = 0; movieNumber < m_movies.length; ++movieNumber)
{
if (m_movies[movieNumber].getTitle().equals(movieTitle))
{
break;
}
}
// Use the weighted average algorithm here (don't forget to check for
// errors).
while(j<m_users.length){
if(j!=userNumber){
weightAvNum = weightAvNum + (m_users[j].getRating(movieNumber)- m_users[j].getAverageRating())*(m_users[userNumber].similarityTo(m_users[j]));
weightAvDen = weightAvDen + (m_users[userNumber].similarityTo(m_users[j]));
}
j++;
}
return (m_users[userNumber].getAverageRating()+ (weightAvNum/weightAvDen));
}
}
class RecommendationError extends Exception
{
/** An error for when something goes wrong in the recommendation process.
*
* #param s A string describing the error.
*/
public RecommendationError(String s)
{
super(s);
}
}
If the file you posted is unaltered from the file that generated the stack trace you posted, then the nullpointer exception on line 75 is somewhere in this code:
weightAvNum = weightAvNum + (m_users[j].getRating(movieNumber)- m_users[j].getAverageRating())*(m_users[userNumber].similarityTo(m_users[j]));
So since m_users is not null (otherwise it would have crashed earlier) either m_users[j] or m_users[userNumber] is null, i.e., there is some null element in the m_users array.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
Can we parse the iPhone/iPad based pList XML from Java on Android?
Please tell me if any such library you have used or know about?
Here is a class I wrote to parse an xml plist file. It uses the XmlPullParser to do the parsing. I have only implemented what I needed for my project. But this should get you started for extending the class if you need more than what this class provides.
File : XMLPropertyListConfiguration.java
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package com.example.plist;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Stack;
import org.xmlpull.v1.XmlPullParser;
import android.annotation.SuppressLint;
import android.util.Xml;
//import android.util.Log;
/**
* This class will parse a plist xml file and store the contents in a
* hierarchical HashMap of <String, Object> tuples, where the Object value could
* be another HashMap, an ArrayList, Boolean, Date, String or Integer value.
*
* Use the getConfiguration methods to retrieve the values from the parsed plist
* file.
*
* The key names for nested dictionary references must be of the form :
* Dict1KeyName.Dict2KeyName.ElementKeyName
*
* #author akoscz
*
*/
public class XMLPropertyListConfiguration {
// private static final String TAG = "plist";
/**
* The nested (hierarchical) HashMap which holds our key-value pairs of our
* plist file.
*/
protected HashMap<String, Object> mPlistHashMap;
/**
* Constructor. Parse a plist file from the given InputStream.
*
* #param inputStream
* The InputStream which has the bytes of the plist file we need
* to parse.
*/
public XMLPropertyListConfiguration(InputStream inputStream) {
mPlistHashMap = new HashMap<String, Object>();
if (inputStream != null) {
parse(inputStream);
}
}
/**
* Get an String configuration value for the given key.
*
* #param keyName
* The name of the key to look up in the configuration
* dictionary.
* #return The String value of the specified key.
*/
public String getConfiguration(String keyName) {
return (String) getConfigurationObject(keyName);
}
/**
* Get a String configuration value for the given key. If there is no value
* for the given key, then return the default value.
*
* #param keyName
* The name of the key to look up in the configuration
* dictionary.
* #param defaultValue
* The default value to return if they key has no associated
* value.
* #return The String value of the specified key, or defaultValue if the
* value for keyName is null.
*/
public String getConfigurationWithDefault(String keyName, String defaultValue) {
String value = getConfiguration(keyName);
if (value == null) {
return defaultValue;
}
return value;
}
/**
* Get an Integer configuration value for the given key.
*
* #param keyName
* The name of the key to look up in the configuration
* dictionary.
* #return The Integer value of the specified key.
*/
public Integer getConfigurationInteger(String keyName) {
return (Integer) getConfigurationObject(keyName);
}
/**
* Get an Integer configuration value for the given key. If there is no
* value for the given key, then return the default value.
*
* #param keyName
* The name of the key to look up in the configuration
* dictionary.
* #param defaultValue
* The default value to return if they key has no associated
* value.
* #return The Integer value of the specified key, or defaultValue if the
* value for keyName is null.
*/
public Integer getConfigurationIntegerWithDefault(String keyName, Integer defaultValue) {
Integer value = getConfigurationInteger(keyName);
if (value == null) {
return defaultValue;
}
return value;
}
/**
* Get a Date configuration value for the given key.
*
* #param keyName
* The name of the key to look up in the configuration
* dictionary.
* #return The Date value of the specified key.
*/
public Date getConfigurationDate(String keyName) {
return (Date) getConfigurationObject(keyName);
}
/**
* Get a Date configuration value for the given key. If there is no value
* for the given key, then return the default value.
*
* #param keyName
* The name of the key to look up in the configuration
* dictionary.
* #param defaultValue
* The default value to return if they key has no associated
* value.
* #return The Date value of the specified key, or defaultValue if the value
* for keyName is null.
*/
public Date getConfigurationDateWithDefault(String keyName, Date defaultValue) {
Date value = getConfigurationDate(keyName);
if (value == null) {
return defaultValue;
}
return value;
}
/**
* Get a Boolean configuration value for the given key.
*
* #param keyName
* The name of the key to look up in the configuration
* dictionary.
* #return The Boolean value of the specified key.
*/
public Boolean getConfigurationBoolean(String keyName) {
return (Boolean) getConfigurationObject(keyName);
}
/**
* Get a Boolean configuration value for the given key. If there is no
* value for the given key, then return the default value.
*
* #param keyName
* The name of the key to look up in the configuration
* dictionary.
* #param defaultValue
* The default value to return if they key has no associated
* value.
* #return The Boolean value of the specified key, or defaultValue if the
* value for keyName is null.
*/
public Boolean getConfigurationBooleanWithDefault(String keyName,
Boolean defaultValue) {
Boolean value = getConfigurationBoolean(keyName);
if (value == null) {
return defaultValue;
}
return value;
}
/**
* Utility method which uses a XmlPullParser to iterate through the XML
* elements and build up a hierarchical HashMap representing the key-value
* pairs of the plist configuration file.
*
* #param inputStream
* The InputStream which contains the plist XML file.
*/
public void parse(InputStream inputStream) {
mPlistHashMap.clear();
XmlPullParser parser = Xml.newPullParser();
try {
parser.setInput(inputStream, null);
int eventType = parser.getEventType();
int arrayDepth = 0;
boolean done = false;
boolean parsingArray = false;
String name = null;
String key = null;
Stack<HashMap<String, Object>> stack = new Stack<HashMap<String, Object>>();
HashMap<String, Object> dict = null;
ArrayList<Object> array = null;
while (eventType != XmlPullParser.END_DOCUMENT && !done) {
switch (eventType) {
case XmlPullParser.START_DOCUMENT:
// Log.d(TAG, "START_DOCUMENT");
break;
case XmlPullParser.START_TAG:
name = parser.getName();
if (name.equalsIgnoreCase("dict")) {
// root dict element
if (key == null) {
mPlistHashMap.clear();
dict = mPlistHashMap;
} else if (parsingArray) {
// Log.d(TAG, "START_TAG dict : inside array");
HashMap<String, Object> childDict = new HashMap<String, Object>();
array.add(childDict);
stack.push(dict);
dict = childDict;
} else {
// Log.d(TAG, "START_TAG dict : " + key);
HashMap<String, Object> childDict = new HashMap<String, Object>();
dict.put(key, childDict);
stack.push(dict);
dict = childDict;
}
} else if (name.equalsIgnoreCase("key")) {
key = parser.nextText();
} else if (name.equalsIgnoreCase("integer")) {
dict.put(key, Integer.valueOf(parser.nextText()));
} else if (name.equalsIgnoreCase("string")) {
if (parsingArray && (parser.getDepth() == (arrayDepth + 1))) {
array.add(parser.nextText());
} else {
dict.put(key, parser.nextText());
}
} else if (name.equalsIgnoreCase("array")) {
parsingArray = true;
array = new ArrayList<Object>();
dict.put(key, array);
arrayDepth = parser.getDepth();
} else if (name.equalsIgnoreCase("date")) {
dict.put(key, parseDate(parser.nextText()));
} else if (name.equalsIgnoreCase("true")) {
dict.put(key, Boolean.TRUE);
} else if (name.equalsIgnoreCase("false")) {
dict.put(key, Boolean.FALSE);
}
break;
case XmlPullParser.END_TAG:
name = parser.getName();
if (name.equalsIgnoreCase("dict")) {
// Log.d(TAG, "END_TAG dict");
if (!stack.empty()) {
dict = stack.pop();
}
} else if (name.equalsIgnoreCase("array")) {
parsingArray = false;
array = null;
} else if (name.equalsIgnoreCase("plist")) {
done = true;
}
break;
case XmlPullParser.END_DOCUMENT:
// Log.d(TAG, "END_DOCUMENT");
break;
}
eventType = parser.next();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Method to parse an ISO8601 string to a Date object.
* http://www.java2s.com/Code/Java/Data-Type/ISO8601dateparsingutility.htm
*
* #param input
* The ISO8601 date string
* #return The Date object representing the ISO8601 date string.
* #throws java.text.ParseException
*/
#SuppressLint("SimpleDateFormat")
public static Date parseDate(String input) throws java.text.ParseException {
// NOTE: SimpleDateFormat uses GMT[-+]hh:mm for the TZ which breaks
// things a bit. Before we go on we have to repair this.
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssz");
// this is zero time so we need to add that TZ indicator for
if (input.endsWith("Z")) {
input = input.substring(0, input.length() - 1) + "GMT-00:00";
} else {
int inset = 6;
String s0 = input.substring(0, input.length() - inset);
String s1 = input.substring(input.length() - inset, input.length());
input = s0 + "GMT" + s1;
}
return df.parse(input);
}
/**
* Utility method which tokenizes the given keyName using the "." delimiter
* and then looks up each token in the configuration dictionary. If the
* token key points to a dictionary then it proceeds to the next token key
* and looks up value of the token key in the dictionary it found from the
* previous token key.
*
* #param keyName
* The fully qualified key name.
* #return The Object value associated with the given key, or null if the
* key does not exist.
*/
#SuppressWarnings("unchecked")
protected Object getConfigurationObject(String keyName) {
String[] tokens = keyName.split("\\.");
if (tokens.length > 1) {
HashMap<String, Object> dict = mPlistHashMap;
Object obj;
for (int i = 0; i < tokens.length; i++) {
obj = dict.get(tokens[i]);
if (obj instanceof HashMap<?, ?>) {
dict = (HashMap<String, Object>) obj;
continue;
}
return obj;
}
}
return mPlistHashMap.get(keyName);
}
}
Following is a convenience class which extends XMLPropertyListConfiguration to encapsulate the logic of parsing your domain specific plist file. The getter methods are simple delegates to the parent class getConfiguration() methods. Note that you can specify default values to be returned if the key is not present in the plist file.
I have also added some debug methods to print out the keys and values to the debug log.
File : ExamplePListParser.java
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package com.example.plist;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import android.util.Log;
public class ExamplePListParser extends XMLPropertyListConfiguration {
private static final String TAG = "ExamplePListParser";
public ExamplePListParser(InputStream inputStream) {
super(inputStream);
}
public Integer getVersion() {
return getConfigurationIntegerWithDefault("Version", 1);
}
public String getUrl() {
return getConfigurationWithDefault("Url", "http://");
}
public Integer getBrowserVideoWidth(){
return getConfigurationIntegerWithDefault("Browser.VideoWidth", 1280);
}
public Integer getBrowserVideoHeight(){
return getConfigurationIntegerWithDefault("Browser.VideoHeight", 800);
}
public String getRating() {
return getConfigurationWithDefault("Rating", "G");
}
public Date getExpireDate() {
return getConfigurationDateWithDefault("ExpireDate", new Date());
}
public Boolean getHighRes() {
return getConfigurationBooleanWithDefault("HighRes", Boolean.TRUE);
}
/**
* Debug method. Print all the "dict" key names from our plist configuration
* file
*/
public void dumpKeys() {
printHashKeys("root", mPlistHashMap);
}
/**
* Debug method. Iterate through all the methods of this class and print our
* the resulting values.
*/
public void dumpValues() {
try {
Class<? extends XMLPropertyListConfiguration> c = this.getClass();
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
// only invoke getter methods
if (m[i].getName().startsWith("get")) {
// Log.d(TAG, m[i].getName());
if (m[i].getReturnType() == Integer.class) {
Log.d(TAG, m[i].getName() + " --> " + (Integer) m[i].invoke(this, (Object[]) null));
} else if (m[i].getReturnType() == ArrayList.class) {
Log.d(TAG, m[i].getName() + " --> Array");
dumpArrayList((ArrayList<?>) m[i].invoke(this, (Object[]) null));
} else if (m[i].getReturnType() == Date.class) {
Log.d(TAG, m[i].getName() + " --> " + (Date) m[i].invoke(this, (Object[]) null));
} else if (m[i].getReturnType() == Boolean.class) {
Log.d(TAG, m[i].getName() + " --> " + (Boolean) m[i].invoke(this, (Object[]) null));
} else if (m[i].getReturnType() == String.class) {
Log.d(TAG, m[i].getName() + " --> " + (String) m[i].invoke(this, (Object[]) null));
} else {
Log.d(TAG, m[i].getName() + " --> UNSUPPORTED TYPE");
}
}
}
} catch (Throwable e) {
e.printStackTrace();
}
}
private void dumpArrayList(ArrayList<?> list) {
for (Iterator<?> iter = list.iterator(); iter.hasNext();) {
Object o = iter.next();
if (o instanceof String) {
Log.d(TAG, "\t" + (String) o);
} else if (o instanceof Integer) {
Log.d(TAG, "\t" + (Integer) o);
} else if (o instanceof HashMap) {
Log.d(TAG, "\tHashMap");
#SuppressWarnings("unchecked")
HashMap<String, Object> hash = (HashMap<String, Object>) o;
for (Iterator<String> hashIter = hash.keySet().iterator(); hashIter.hasNext();) {
String key = hashIter.next();
Object value = hash.get(key);
if (value instanceof Integer) {
Log.d(TAG, "\t\t " + key + " = " + (Integer) value);
} else if (value instanceof String) {
Log.d(TAG, "\t\t " + key + " = " + (String) value);
}
}
}
}
}
/**
* Debug method. Iterate through all the keys in the HashMap (dict) and
* print the key names for each child HashMap (dict).
*/
#SuppressWarnings("unchecked")
private void printHashKeys(String key, HashMap<String, Object> map) {
Set<String> keys = map.keySet();
Log.d(TAG, key + " --> " + keys.toString());
for (Iterator<String> iter = keys.iterator(); iter.hasNext();) {
key = iter.next();
Object o = map.get(key);
if (o instanceof HashMap) {
printHashKeys(key, (HashMap<String, Object>) o);
}
}
}
}
Here is a sample plist file.
File : sample.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Version</key>
<integer>3</integer>
<key>Url</key>
<string>http://example.com/video.mp4</string>
<key>ExpireDate</key>
<date>2013-4-20T11:20:00Z</date>
<key>HighRes</key>
<false/>
<key>Browser</key>
<dict>
<key>VideoWidth</key>
<integer>640</integer>
<key>VideoHeight</key>
<integer>480</integer>
</dict>
</dict>
</plist>
Sample Usage :
ExamplePListParser mPListParser;
InputStream inputStream = new FileInputStream("/sdcard/sample.xml");
if(mPListParser == null) {
mPListParser = new ExamplePListParser(inputStream);
} else {
mPListParser.parse(inputStream);
}
int version = mPListParser.getVersion();
int height = mPListParser.getBrowserVideoHeight();
int width = mPListParser.getBrowserVideoWidth();
String url = mPListParser.getUrl();
String rating = mPListParser.getRating();
Date expireDate = mPListParser.getExpireDate();
boolean highRes = mPListParser.getHighRes();
// debug: print out keys and values
mPListParser.dumpKeys();
mPListParser.dumpValues();
Try it
http://code.google.com/p/xmlwise/
I'm testing it right now.
Since a plist is just an XML file, you can use any of the available XML parsers. Personally, I use XmlPullParser for small files.
Akos' code is imo the best response to this question so far. However, his algorithm does not work for nested arrays, and it doesn't support all PList tags. I'm working on a more generalized SAX-based implementation for PList parsing in Android. I'll post the code on my blog upon request.
The PList parser I promised can be found at: https://github.com/tenaciousRas/android-plist-parser
Have fun!
This isn't exactly what you asked but it is what I did rather than add a code dependency to my project.
You can convert the PList file to a JSON file and use the built in JSON parser. There is a tool to do this on OSX which comes with the developer tools (I think, that or it is just installed by default).
plutil -convert json Days.plist